fix readme

.devcontainer/Dockerfile

@@ -0,0 +1,29 @@
+# Source: https://github.com/a5chin/python-uv
+FROM debian:bookworm-slim AS builder
+
+ENV CARGO_HOME="/opt/.cargo"
+
+SHELL [ "/bin/bash", "-o", "pipefail", "-c" ]
+
+WORKDIR /opt
+
+# The installer requires curl (and certificates) to download the release archive
+# hadolint ignore=DL3008
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends ca-certificates curl
+
+# Run uv installer
+RUN curl -LsSf https://astral.sh/uv/install.sh | sh
+
+
+FROM mcr.microsoft.com/vscode/devcontainers/base:bookworm
+
+
+ENV CARGO_HOME="/opt/.cargo"
+ENV PATH="$CARGO_HOME/bin/:$PATH"
+ENV PYTHONUNBUFFERED=True
+ENV UV_LINK_MODE=copy
+
+WORKDIR /opt
+
+COPY --from=builder --chown=vscode: $CARGO_HOME $CARGO_HOME

.devcontainer/demo/README.md

@@ -0,0 +1,15 @@
+# Langflow Demo Codespace Readme
+
+These instructions will walk you through the process of running a Langflow demo via GitHub Codespaces.
+
+## Setup
+
+### Create a Codespace in GitHub
+
+To setup the demo, simply navigate to the Langflow repo, click the "+" button, and select "Create new Codespace". This will automatically create a new codespace in your browser, which you can use for the demo.
+
+### Wait for everything to install
+
+After the codespace is opened, you should see a new Terminal window in VS Code where langflow is installed. Once the install completes, `langflow` will launch the webserver and your application will be available via devcontainer port. 
+
+Note: VS Code should prompt you with a button to push once the port is available.

.devcontainer/demo/devcontainer.json

@@ -0,0 +1,33 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/universal
+{
+  "name": "Langflow Demo Container",
+  // Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
+  "image": "mcr.microsoft.com/devcontainers/python:3.10",
+  "features": {
+    "ghcr.io/devcontainers/features/aws-cli:1": {},
+    "ghcr.io/devcontainers/features/docker-in-docker": {},
+    "ghcr.io/devcontainers/features/node": {}
+  },
+  "customizations": {
+    "vscode": {
+      "extensions": [
+        "actboy168.tasks",
+        "GitHub.copilot",
+        "ms-python.python",
+        "eamodio.gitlens",
+        "GitHub.vscode-pull-request-github"
+      ]
+    }
+  },
+  // Features to add to the dev container. More info: https://containers.dev/features.
+  // "features": {},
+  // Use 'forwardPorts' to make a list of ports inside the container available locally.
+  // "forwardPorts": [],
+  // Use 'postCreateCommand' to run commands after the container is created.
+  "postCreateCommand": "pipx install 'langflow>=0.0.33' && langflow --host 0.0.0.0"
+  // Configure tool-specific properties.
+  // "customizations": {},
+  // Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+  // "remoteUser": "root"
+}

.devcontainer/devcontainer.json

@@ -0,0 +1,51 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/universal
+{
+  "name": "Langflow Dev Container",
+  "build": {
+    "context": "..",
+    "dockerfile": "Dockerfile"
+  },
+  // Features to add to the dev container. More info: https://containers.dev/features.
+  "features": {
+    "ghcr.io/devcontainers/features/node": {},
+    "ghcr.io/dhoeric/features/hadolint:1": {}
+  },
+
+  // Use 'forwardPorts' to make a list of ports inside the container available locally.
+  // "forwardPorts": [],
+
+  // Use 'postCreateCommand' to run commands after the container is created.
+  "postCreateCommand": "make install_frontend && make install_backend",
+  "postStartCommand": "make init",
+
+  // Configure tool-specific properties.
+  "customizations": {
+    "vscode": {
+      "extensions": [
+        "charliermarsh.ruff",
+        "njpwerner.autodocstring",
+        "oderwat.indent-rainbow",
+        "exiasr.hadolint",
+        "actboy168.tasks",
+        "GitHub.copilot",
+        "ms-python.python",
+        "eamodio.gitlens",
+        "ms-vscode.makefile-tools",
+        "GitHub.vscode-pull-request-github"
+      ],
+      "settings": {
+        "terminal.integrated.defaultProfile.linux": "zsh",
+        "terminal.integrated.profiles.linux": {
+          "zsh": {
+            "path": "/bin/zsh"
+          }
+        }
+      }
+    }
+  },
+
+  // Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+  // "remoteUser": "root"
+  "remoteUser": "vscode"
+}

.env.example

@@ -0,0 +1,104 @@
+# Description: Example of .env file
+# Usage: Copy this file to .env and change the values
+#        according to your needs
+#        Do not commit .env file to git
+#        Do not change .env.example file
+
+# Config directory
+# Directory where files, logs and database will be stored
+# Example: LANGFLOW_CONFIG_DIR=~/.langflow
+LANGFLOW_CONFIG_DIR=
+
+# Save database in the config directory
+# Values: true, false
+# If false, the database will be saved in Langflow's root directory
+# This means that the database will be deleted when Langflow is uninstalled
+# and that the database will not be shared between different virtual environments
+# Example: LANGFLOW_SAVE_DB_IN_CONFIG_DIR=true
+LANGFLOW_SAVE_DB_IN_CONFIG_DIR=
+
+# Database URL
+# Postgres example: LANGFLOW_DATABASE_URL=postgresql://postgres:postgres@localhost:5432/langflow
+# SQLite example:
+LANGFLOW_DATABASE_URL=sqlite:///./langflow.db
+
+# Cache type
+LANGFLOW_LANGCHAIN_CACHE=SQLiteCache
+
+# Server host
+# Example: LANGFLOW_HOST=127.0.0.1
+LANGFLOW_HOST=
+
+# Worker processes
+# Example: LANGFLOW_WORKERS=1
+LANGFLOW_WORKERS=
+
+# Server port
+# Example: LANGFLOW_PORT=7860
+LANGFLOW_PORT=
+
+# Logging level
+# Example: LANGFLOW_LOG_LEVEL=critical
+LANGFLOW_LOG_LEVEL=
+
+# Path to the log file
+# Example: LANGFLOW_LOG_FILE=logs/langflow.log
+LANGFLOW_LOG_FILE=
+
+# Path to the frontend directory containing build files
+# Example: LANGFLOW_FRONTEND_PATH=/path/to/frontend/build/files
+LANGFLOW_FRONTEND_PATH=
+
+# Whether to open the browser after starting the server
+# Values: true, false
+# Example: LANGFLOW_OPEN_BROWSER=true
+LANGFLOW_OPEN_BROWSER=
+
+# Whether to remove API keys from the projects saved in the database
+# Values: true, false
+# Example: LANGFLOW_REMOVE_API_KEYS=false
+LANGFLOW_REMOVE_API_KEYS=
+
+# Whether to use RedisCache or ThreadingInMemoryCache or AsyncInMemoryCache
+# Values: async, memory, redis
+# Example: LANGFLOW_CACHE_TYPE=memory
+# If you want to use redis then the following environment variables must be set:
+# LANGFLOW_REDIS_HOST (default: localhost)
+# LANGFLOW_REDIS_PORT (default: 6379)
+# LANGFLOW_REDIS_DB (default: 0)
+# LANGFLOW_REDIS_CACHE_EXPIRE (default: 3600)
+LANGFLOW_CACHE_TYPE=
+
+# Set AUTO_LOGIN to false if you want to disable auto login
+# and use the login form to login. LANGFLOW_SUPERUSER and LANGFLOW_SUPERUSER_PASSWORD
+# must be set if AUTO_LOGIN is set to false
+# Values: true, false
+LANGFLOW_AUTO_LOGIN=
+
+# Superuser username
+# Example: LANGFLOW_SUPERUSER=admin
+LANGFLOW_SUPERUSER=
+
+# Superuser password
+# Example: LANGFLOW_SUPERUSER_PASSWORD=123456
+LANGFLOW_SUPERUSER_PASSWORD=
+
+# Should store environment variables in the database
+# Values: true, false
+LANGFLOW_STORE_ENVIRONMENT_VARIABLES=
+
+# STORE_URL
+# Example: LANGFLOW_STORE_URL=https://api.langflow.store
+# LANGFLOW_STORE_URL=
+
+# DOWNLOAD_WEBHOOK_URL
+#
+# LANGFLOW_DOWNLOAD_WEBHOOK_URL=
+
+# LIKE_WEBHOOK_URL
+#
+# LANGFLOW_LIKE_WEBHOOK_URL=
+
+# Value must finish with slash /
+#BACKEND_URL=http://localhost:7860/
+BACKEND_URL=

.eslintrc.json

@@ -0,0 +1,90 @@
+{
+    "extends": [
+        "eslint:recommended",
+        "plugin:react/recommended",
+        "plugin:prettier/recommended"
+    ],
+    "plugins": [
+        "react",
+        "import-helpers",
+        "prettier"
+    ],
+    "parser": "@typescript-eslint/parser",
+    "parserOptions": {
+        "project": [
+            "./tsconfig.node.json",
+            "./tsconfig.json"
+        ],
+        "extraFileExtensions:": [
+            ".mdx"
+        ],
+        "extensions:": [
+            ".mdx"
+        ]
+    },
+    "env": {
+        "browser": true,
+        "es2021": true
+    },
+    "settings": {
+        "react": {
+            "version": "detect"
+        }
+    },
+    "rules": {
+        "no-console": "warn",
+        "no-self-assign": "warn",
+        "no-self-compare": "warn",
+        "complexity": [
+            "error",
+            {
+                "max": 15
+            }
+        ],
+        "indent": [
+            "error",
+            2,
+            {
+                "SwitchCase": 1
+            }
+        ],
+        "no-dupe-keys": "error",
+        "no-invalid-regexp": "error",
+        "no-undef": "error",
+        "no-return-assign": "error",
+        "no-redeclare": "error",
+        "no-empty": "error",
+        "no-await-in-loop": "error",
+        "react/react-in-jsx-scope": 0,
+        "node/exports-style": [
+            "error",
+            "module.exports"
+        ],
+        "node/file-extension-in-import": [
+            "error",
+            "always"
+        ],
+        "node/prefer-global/buffer": [
+            "error",
+            "always"
+        ],
+        "node/prefer-global/console": [
+            "error",
+            "always"
+        ],
+        "node/prefer-global/process": [
+            "error",
+            "always"
+        ],
+        "node/prefer-global/url-search-params": [
+            "error",
+            "always"
+        ],
+        "node/prefer-global/url": [
+            "error",
+            "always"
+        ],
+        "node/prefer-promises/dns": "error",
+        "node/prefer-promises/fs": "error"
+    }
+}

.gitattributes

@@ -1,35 +1,32 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Set the default behavior, in case people don't have core.autocrlf set.
+* text eol=lf
+# Explicitly declare text files you want to always be normalized and converted
+# to native line endings on checkout.
+*.c text
+*.h text
+*.py text
+*.js text
+*.jsx text
+*.ts text
+*.tsx text
+*.md text
+*.mdx text
+*.yml text
+*.yaml text
+*.xml text
+*.csv text
+*.json text
+*.sh text
+*.Dockerfile text
+Dockerfile text
+# Declare files that will always have CRLF line endings on checkout.
+*.sln text eol=crlf
+# Denote all files that are truly binary and should not be modified.
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.ico binary
+*.gif binary
+*.mp4 binary
+*.svg binary
+*.csv binary
+*.gif filter=lfs diff=lfs merge=lfs -text

.github/ISSUE_TEMPLATE/bug-report.yaml

@@ -0,0 +1,120 @@
+name: "🐛 Bug Report"
+description: Submit a bug report to help us improve Langflow
+labels: [ "bug" ]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to fill out this bug report!
+        
+  - type: textarea
+    id: description
+    attributes:
+      label: Bug Description
+      description: A clear and concise description of what the bug is
+      placeholder: Tell us what you see!
+    validations:
+      required: true
+
+  - type: textarea
+    id: reproduction
+    validations:
+      required: true
+    attributes:
+      label: Reproduction
+      description: |
+        Please provide a code sample that reproduces the problem you ran into. It can be a Colab link or just a code snippet.
+        If you have code snippets, error messages, or stack traces please provide them here as well.
+        Important! Use code tags to format your code correctly. See https://help.github.com/en/github/writing-on-github/creating-and-highlighting-code-blocks#syntax-highlighting
+        Do not use screenshots, as they are hard to read, and (more importantly) don't allow others to copy-and-paste your code.
+      placeholder: |
+        Steps to reproduce the behavior:
+
+          1.
+          2.
+          3.
+
+  - type: textarea
+    id: expected-behavior
+    validations:
+      required: true
+    attributes:
+      label: Expected behavior
+      description: "A clear and concise description of what you would expect to happen."
+
+  - type: textarea
+    id: who-can-help
+    attributes:
+      label: Who can help?
+      description: |
+        Your issue will be replied to more quickly if you can figure out the right person to tag with @.
+        If you know the relevant code owner, please tag them. Otherwise, leave this blank and a core maintainer will direct the issue accordingly.
+
+        Please tag fewer than 3 people.
+
+        Specific Areas:
+
+          Frontend:
+            - @anovazzi1
+            - @Cristhianzl
+            - @lucaseduoli
+            - @igorrCarvalho
+            
+          Backend:
+            - @italojohnny
+            
+          Full Stack:
+            - @ogabrielluiz
+            - @nicoloboschi
+            - @zzzming
+            - @jordanrfrazier
+            - @mfortman11
+            - @NadirJ
+
+      placeholder: "@Username ..."
+
+  - type: markdown
+    attributes:
+      value: '## Environment'
+      
+  - type: input
+    id: os
+    attributes:
+      label: Operating System
+      placeholder: ex. Ubuntu Linux 22.04
+    validations:
+      required: true
+      
+  - type: input
+    id: langflow-version
+    attributes:
+      label: Langflow Version
+      placeholder: ex. 1.0.9
+    validations:
+      required: true
+
+  - type: dropdown
+    id: python-version
+    attributes:
+      label: "Python Version"
+      description: |
+
+        **Langflow requires Python version 3.10 or greater.**
+      options:
+        - "3.12"
+        - "3.11"
+        - "3.10"
+
+  - type: textarea
+    id: screenshot
+    attributes:
+      label: Screenshot
+      description: "If applicable, add screenshots to help explain your problem."
+      placeholder: "Paste your screenshot here."
+
+  - type: textarea
+    id: flow-file
+    attributes:
+      label: Flow File
+      description: "Add your flow if applicable to help replicate the problem."
+      placeholder: "Add your flow link here."

.github/ISSUE_TEMPLATE/feature-request.yaml

@@ -0,0 +1,28 @@
+name: "🚀 Feature Request"
+description: Submit a proposal/request for a new Langflow feature
+labels: [ "enhancement" ]
+body:
+  - type: textarea
+    id: feature-request
+    validations:
+      required: true
+    attributes:
+      label: Feature Request
+      description: |
+        A clear and concise description of the feature proposal. Please provide any relevant links to papers, code, or other resources that support your proposal.
+
+  - type: textarea
+    id: motivation
+    validations:
+      required: true
+    attributes:
+      label: Motivation
+      description: |
+        Please outline the motivation for the proposal. Is your feature request related to a problem? e.g., I'm always frustrated when [...]. If this is related to another GitHub issue, please link it here as well.
+
+  - type: textarea
+    id: contribution
+    attributes:
+      label: Your Contribution
+      description: |
+        Is there any way that you could help, e.g., by submitting a PR? Make sure to read the CONTRIBUTING.md guidelines for Langflow before proceeding.

.github/ISSUE_TEMPLATE/work-in-progress.yaml

@@ -0,0 +1,58 @@
+name: Work in Progress
+description: Use this template to describe the new feature or improvement you are currently working on.
+labels: [enhancement]
+
+body:
+  - type: markdown
+    attributes:
+      value: |
+        ## Work in Progress
+
+        Thank you for contributing to our project! Please fill out the sections below to describe the new feature or improvement you are currently working on.
+
+  - type: input
+    id: title
+    attributes:
+      label: Title
+      description: Provide a concise title for your feature or improvement.
+      placeholder: "Short and descriptive title"
+    validations:
+      required: true
+
+  - type: dropdown
+    id: type
+    attributes:
+      label: Type
+      description: Is this a new feature or an improvement?
+      options:
+        - New Feature
+        - Improvement
+    validations:
+      required: true
+
+  - type: textarea
+    id: description
+    attributes:
+      label: Description
+      description: Provide a detailed description of the feature or improvement.
+      placeholder: "Explain the feature or improvement in detail"
+    validations:
+      required: true
+
+  - type: textarea
+    id: use-case
+    attributes:
+      label: Use Case
+      description: Describe the use case or user story that this feature or improvement addresses.
+      placeholder: "As a [user], I want to [do something] so that [benefit]."
+    validations:
+      required: false
+
+  - type: textarea
+    id: implementation
+    attributes:
+      label: Implementation Plan
+      description: Outline your plan for implementing this feature or improvement.
+      placeholder: "Describe how you plan to implement this feature or improvement."
+    validations:
+      required: false

.github/actions/install-playwright/action.yml

@@ -0,0 +1,76 @@
+name: Install Playwright
+description: Install Playwright and dependencies with cache
+
+# https://github.com/microsoft/playwright/issues/7249
+
+inputs:
+  working-directory:
+    description: Where to install Playwright
+    default: ./
+  browsers:
+    description: Browsers to install
+    default: chromium webkit firefox
+
+outputs:
+  version:
+    description: Installed version of Playwright
+    value: ${{ steps.version.outputs.version }}
+  cache-hit:
+    description: Whether cache for Playwright was found
+    value: ${{ steps.cache.outputs.cache-hit }}
+
+runs:
+  using: composite
+  steps:
+    - name: Get Playwright version
+      uses: actions/github-script@v7
+      id: version
+      with:
+        script: |
+          const fs = require('fs');
+          const path = require('path');
+
+          // Get working directory
+          const workingDirectory = "${{ inputs.working-directory }}";
+          console.debug("Specified working directory:", workingDirectory);
+          if (workingDirectory) process.chdir(workingDirectory);
+          console.debug("Actual working directory:", process.cwd());
+
+          // Read package.json
+          let version = "";
+          try {
+            const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+            version = (
+              packageJson.devDependencies?.['@playwright/test'] ||
+              packageJson.dependencies?.['@playwright/test'] ||
+              packageJson.dependencies?.['playwright'] ||
+              packageJson.devDependencies?.['playwright']
+            )?.replace(/[\^~]/g, '');
+          } catch (error) {
+            console.log(error.message);
+          }
+
+          console.debug("Version:", version);
+          if (version) {
+            core.exportVariable("PLAYWRIGHT_VERSION", version);
+            core.setOutput("version", version);
+          } else core.setFailed("Couldn't get Playwright version");
+
+    - name: Cache Playwright
+      id: cache
+      uses: actions/cache@v4
+      with:
+        path: ~/.cache/ms-playwright
+        key: playwright-${{ env.PLAYWRIGHT_VERSION }}
+
+    - name: Install Playwright and its dependencies
+      shell: bash
+      if: steps.cache.outputs.cache-hit != 'true'
+      working-directory: ${{ inputs.working-directory }}
+      run: npx playwright install ${{ inputs.browsers }} --with-deps
+
+    - name: Install just Playwright's dependencies
+      shell: bash
+      if: steps.cache.outputs.cache-hit == 'true'
+      working-directory: ${{ inputs.working-directory }}
+      run: npx playwright install-deps

.github/actions/poetry_caching/action.yml

@@ -0,0 +1,99 @@
+# An action for setting up poetry install with caching.
+# Using a custom action since the default action does not
+# take poetry install groups into account.
+# Action code from:
+# https://github.com/actions/setup-python/issues/505#issuecomment-1273013236
+# Copy of https://github.com/langchain-ai/langchain/blob/2f8dd1a1619f25daa4737df4d378b1acd6ff83c4/.github/actions/poetry_setup/action.yml
+name: poetry-install-with-caching
+description: Poetry install with support for caching of dependency groups.
+
+inputs:
+  python-version:
+    description: Python version, supporting MAJOR.MINOR only
+    required: true
+
+  poetry-version:
+    description: Poetry version
+    required: true
+
+  cache-key:
+    description: Cache key to use for manual handling of caching
+    required: true
+
+  working-directory:
+    description: Directory whose poetry.lock file should be cached
+    required: true
+
+runs:
+  using: composite
+  steps:
+    - uses: actions/setup-python@v5
+      name: Setup python ${{ inputs.python-version }}
+      id: setup-python
+      with:
+        python-version: ${{ inputs.python-version }}
+
+    - uses: actions/cache@v4
+      id: cache-bin-poetry
+      name: Cache Poetry binary - Python ${{ inputs.python-version }}
+      env:
+        SEGMENT_DOWNLOAD_TIMEOUT_MIN: "1"
+      with:
+        path: |
+          /opt/pipx/venvs/poetry
+        # This step caches the poetry installation, so make sure it's keyed on the poetry version as well.
+        key: bin-poetry-${{ runner.os }}-${{ runner.arch }}-py-${{ inputs.python-version }}-${{ inputs.poetry-version }}
+
+    - name: Refresh shell hashtable and fixup softlinks
+      if: steps.cache-bin-poetry.outputs.cache-hit == 'true'
+      shell: bash
+      env:
+        POETRY_VERSION: ${{ inputs.poetry-version }}
+        PYTHON_VERSION: ${{ inputs.python-version }}
+      run: |
+        set -eux
+
+        # Refresh the shell hashtable, to ensure correct `which` output.
+        hash -r
+
+        # `actions/cache@v3` doesn't always seem able to correctly unpack softlinks.
+        # Delete and recreate the softlinks pipx expects to have.
+        rm /opt/pipx/venvs/poetry/bin/python
+        cd /opt/pipx/venvs/poetry/bin
+        ln -s "$(which "python$PYTHON_VERSION")" python
+        chmod +x python
+        cd /opt/pipx_bin/
+        ln -s /opt/pipx/venvs/poetry/bin/poetry poetry
+        chmod +x poetry
+
+        # Ensure everything got set up correctly.
+        /opt/pipx/venvs/poetry/bin/python --version
+        /opt/pipx_bin/poetry --version
+
+    - name: Install poetry
+      if: steps.cache-bin-poetry.outputs.cache-hit != 'true'
+      shell: bash
+      env:
+        POETRY_VERSION: ${{ inputs.poetry-version || env.POETRY_VERSION }}
+        PYTHON_VERSION: ${{ inputs.python-version }}
+      # Install poetry using the python version installed by setup-python step.
+      run: |
+        pipx install "poetry==$POETRY_VERSION" --python '${{ steps.setup-python.outputs.python-path }}' --verbose
+        pipx ensurepath
+        # Ensure the poetry binary is available in the PATH.
+        # Test that the poetry binary is available.
+        poetry --version
+
+    - name: Restore pip and poetry cached dependencies
+      uses: actions/cache@v4
+      env:
+        SEGMENT_DOWNLOAD_TIMEOUT_MIN: "4"
+        WORKDIR: ${{ inputs.working-directory == '' && '.' || inputs.working-directory }}
+      with:
+        path: |
+          ~/.cache/pip
+          ~/.cache/pypoetry/virtualenvs
+          ~/.cache/pypoetry/cache
+          ~/.cache/pypoetry/artifacts
+          ${{ env.WORKDIR }}/.venv
+        key: py-deps-${{ runner.os }}-${{ runner.arch }}-py-${{ inputs.python-version }}-poetry-${{ inputs.poetry-version }}-${{ inputs.cache-key }}-${{ hashFiles(format('{0}/**/poetry.lock', env.WORKDIR)) }}

.github/actions/setup-uv/action.yml

@@ -0,0 +1,25 @@
+name: "Setup uv"
+description: "Checks out code, installs uv, and sets up Python environment"
+
+runs:
+  using: "composite"
+  steps:
+    - name: Install uv
+      uses: astral-sh/setup-uv@v3
+      with:
+        enable-cache: true
+        cache-dependency-glob: "uv.lock"
+
+    - name: "Set up Python"
+      uses: actions/setup-python@v5
+      with:
+        python-version-file: "pyproject.toml"
+
+    - name: Restore uv cache
+      uses: actions/cache@v4
+      with:
+        path: /tmp/.uv-cache
+        key: uv-${{ runner.os }}-${{ hashFiles('uv.lock') }}
+        restore-keys: |
+          uv-${{ runner.os }}-${{ hashFiles('uv.lock') }}
+          uv-${{ runner.os }}

.github/changes-filter.yaml

@@ -0,0 +1,71 @@
+# https://github.com/dorny/paths-filter
+python:
+  - "src/backend/**"
+  - "src/backend/**.py"
+  - "pyproject.toml"
+  - "poetry.lock"
+  - "**/python_test.yml"
+components-changes:
+  - "src/backend/base/langflow/components/**"
+starter-projects-changes:
+  - "src/backend/base/langflow/initial_setup/**"
+frontend-tests:
+  - "src/frontend/tests/**"
+frontend:
+  - "src/frontend/**"
+  - "**/typescript_test.yml"
+docs:
+  - "docs/**"
+
+# Test categories and their associated paths
+starter-projects:
+  - "src/backend/base/langflow/initial_setup/**"
+  - "src/backend/base/langflow/components/**"
+  - "src/frontend/src/pages/MainPage/**"
+  - "src/frontend/src/utils/reactflowUtils.ts"
+  - "src/frontend/tests/extended/features/**"
+
+components:
+  - "src/frontend/src/components/**"
+  - "src/frontend/src/modals/**"
+  - "src/frontend/src/pages/FlowPage/**"
+  - "src/frontend/src/shared/**"
+  - "src/frontend/src/hooks/**"
+  - "src/frontend/src/CustomNodes/**"
+  - "src/frontend/src/style/**"
+  - "src/frontend/src/utils/styleUtils.ts"
+  - "src/backend/base/langflow/components/**"
+  - "src/frontend/tests/core/features/**"
+  - "src/frontend/tests/core/integrations/**"
+  - "src/frontend/tests/core/regression/**"
+  - "src/frontend/tests/extended/integrations/**"
+  - "src/frontend/tests/extended/features/**"
+  - "src/frontend/tests/extended/regression/**"
+
+workspace:
+  - "src/backend/base/langflow/inputs/**"
+  - "src/frontend/src/components/core/parameterRenderComponent/**"
+  - "src/frontend/src/CustomNodes/**"
+  - "src/frontend/src/modals/**"
+  - "src/frontend/src/style/**"
+  - "src/frontend/src/CustomEdges/**"
+  - "src/frontend/src/utils/reactflowUtils.ts"
+  - "src/frontend/src/utils/buildUtils.ts"
+  - "src/frontend/tests/core/features/**"
+  - "src/frontend/tests/core/unit/**"
+  - "src/frontend/tests/extended/features/**"
+  - "src/frontend/tests/core/regression/**"
+
+api:
+  - "src/backend/base/langflow/api/**"
+  - "src/frontend/src/controllers/**"
+  - "src/frontend/tests/core/features/**"
+  - "src/frontend/tests/extended/features/**"
+  - "src/frontend/tests/extended/regression/**"
+
+database:
+  - "src/backend/base/langflow/services/database/**"
+  - "src/backend/base/langflow/alembic/**"
+  - "src/frontend/src/controllers/**"
+  - "src/frontend/tests/core/features/**"
+  - "src/frontend/tests/extended/features/**"

.github/dependabot.yml

@@ -0,0 +1,11 @@
+# Set update schedule for GitHub Actions
+
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "monthly"
+    commit-message:
+      prefix: "build(deps):"
+      include: scope

.github/release.yml

@@ -0,0 +1,35 @@
+changelog:
+  categories:
+    - title: 🚨 Breaking Changes
+      description: Changes that break existing functionality
+      labels:
+        - breaking
+    - title: ✨ New Features
+      description: New features and enhancements
+      labels:
+        - enhancement
+    - title: 🐛 Bug Fixes
+      description: Bug fixes and patches
+      labels:
+        - fix
+        - bug
+    - title: 📝 Documentation Updates
+      description: Changes to documentation
+      labels:
+        - documentation
+    - title: 🛠 Maintenance Tasks
+      description: Maintenance tasks and housekeeping
+      labels:
+        - chore
+        - refactor
+        - style
+        - performance
+        - build
+    - title: ✅ Tests
+      description: Changes to tests
+      labels:
+        - test
+    - title: Others
+      description: Other changes
+      labels:
+        - "*"

.github/semantic.yml

@@ -0,0 +1,2 @@
+titleOnly: true
+targetUrl: https://www.conventionalcommits.org/en/v1.0.0/#summary

.github/workflows/auto-update.yml

@@ -0,0 +1,13 @@
+name: Auto-update
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  Auto:
+    name: Auto-update
+    runs-on: ubuntu-latest
+    steps:
+      - uses: tibdex/auto-update@v2

.github/workflows/ci.yml

@@ -0,0 +1,140 @@
+name: CI
+
+on:
+  workflow_call:
+    inputs:
+      python-versions:
+        description: "Python Versions"
+        required: false
+        type: string
+        default: "['3.10']"
+      frontend-tests-folder:
+        description: "Frontend Tests Folder"
+        required: false
+        type: string
+        default: "tests/core"
+      release:
+        description: "Release"
+        required: false
+        type: boolean
+        default: false
+  workflow_dispatch:
+    inputs:
+      branch:
+        description: "(Optional) Branch to checkout"
+        required: false
+        type: string
+      openai_api_key:
+        description: "OpenAI API Key"
+        required: false
+        type: string
+      store_api_key:
+        description: "Store API Key"
+        required: false
+        type: string
+      python-versions:
+        description: "Python Versions"
+        required: false
+        type: string
+        default: "['3.10']"
+  pull_request:
+    types: [synchronize, labeled]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  set-ci-condition:
+    name: Should Run CI
+    runs-on: ubuntu-latest
+    outputs:
+      should-run-ci: ${{ (contains( github.event.pull_request.labels.*.name, 'lgtm') && github.event.pull_request.draft == false) || (github.event_name == 'workflow_dispatch' || github.event_name == 'workflow_call') }}
+    steps:
+      #  Do anything just to make the job run
+      - run: echo "Debug CI Condition"
+      - run: echo "Labels -> ${{ join(github.event.pull_request.labels.*.name, ',') }}"
+      - run: echo "IsDraft -> ${{ github.event.pull_request.draft }}"
+      - run: echo "Event name -> ${{ github.event_name }}"
+  path-filter:
+    needs: set-ci-condition
+    if: ${{ needs.set-ci-condition.outputs.should-run-ci == 'true' }}
+    name: Filter Paths
+    runs-on: ubuntu-latest
+    outputs:
+      python: ${{ steps.filter.outputs.python }}
+      frontend: ${{ steps.filter.outputs.frontend }}
+      docs: ${{ steps.filter.outputs.docs }}
+      frontend-tests: ${{ steps.filter.outputs.frontend-tests }}
+      components-changes: ${{ steps.filter.outputs.components-changes }}
+      starter-projects-changes: ${{ steps.filter.outputs.starter-projects-changes }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.branch || github.ref }}
+      - name: Filter Paths
+        id: filter
+        uses: dorny/paths-filter@v3
+        with:
+          filters: ./.github/changes-filter.yaml
+
+  test-backend:
+    needs: path-filter
+    name: Run Backend Tests
+    if: ${{ needs.path-filter.outputs.python == 'true'}}
+    uses: ./.github/workflows/python_test.yml
+    with:
+      python-versions: ${{ inputs.python-versions || '["3.10"]' }}
+
+  test-frontend:
+    needs: path-filter
+    name: Run Frontend Tests
+    if: ${{ needs.path-filter.outputs.frontend == 'true' || needs.path-filter.outputs.frontend-tests == 'true' || needs.path-filter.outputs.components-changes == 'true' || needs.path-filter.outputs.starter-projects-changes == 'true' }}
+    uses: ./.github/workflows/typescript_test.yml
+    with:
+      tests_folder: ${{ inputs.frontend-tests-folder }}
+      release: ${{ inputs.release || false }}
+    secrets:
+      OPENAI_API_KEY: "${{ secrets.OPENAI_API_KEY }}"
+      STORE_API_KEY: "${{ secrets.STORE_API_KEY }}"
+      ANTHROPIC_API_KEY: "${{ secrets.ANTHROPIC_API_KEY }}"
+      TAVILY_API_KEY: "${{ secrets.TAVILY_API_KEY }}"
+
+  lint-backend:
+    needs: path-filter
+    if: ${{ needs.path-filter.outputs.python == 'true'}}
+    name: Lint Backend
+    uses: ./.github/workflows/lint-py.yml
+
+  test-docs-build:
+    needs: path-filter
+    if: ${{ needs.path-filter.outputs.docs == 'true' }}
+    name: Test Docs Build
+    uses: ./.github/workflows/docs_test.yml
+
+  # https://github.com/langchain-ai/langchain/blob/master/.github/workflows/check_diffs.yml
+  ci_success:
+    name: "CI Success"
+    needs:
+      [
+        test-backend,
+        test-frontend,
+        lint-backend,
+        test-docs-build,
+        set-ci-condition,
+      ]
+
+    if: always()
+    runs-on: ubuntu-latest
+    env:
+      JOBS_JSON: ${{ toJSON(needs) }}
+      RESULTS_JSON: ${{ toJSON(needs.*.result) }}
+      EXIT_CODE: ${{!contains(needs.*.result, 'failure') && !contains(needs.*.result, 'cancelled') && needs.set-ci-condition.outputs.should-run-ci == 'true' && '0' || '1'}}
+    steps:
+      - name: "CI Success"
+        run: |
+          echo $JOBS_JSON
+          echo $RESULTS_JSON
+          echo "Exiting with $EXIT_CODE"
+          exit $EXIT_CODE

.github/workflows/codeql.yml

@@ -0,0 +1,66 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ 'dev', 'main' ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ 'dev' ]
+  schedule:
+    - cron: '17 2 * * 1'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
+    timeout-minutes: ${{ (matrix.language == 'swift' && 120) || 360 }}
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'python', 'javascript' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Use only 'java' to analyze code written in Java, Kotlin or both
+        # Use only 'javascript' to analyze code written in JavaScript, TypeScript or both
+        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v3
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+
+        # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+
+    # Autobuild attempts to build any compiled languages (C/C++, C#, Go, Java, or Swift).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v3
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+
+    #   If the Autobuild fails above, remove it and uncomment the following three lines.
+    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
+
+    # - run: |
+    #     echo "Run, Build Application using script"
+    #     ./location_of_script_within_repo/buildscript.sh
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v3
+      with:
+        category: "/language:${{matrix.language}}"

.github/workflows/codspeed.yml

@@ -0,0 +1,45 @@
+name: Run benchmarks
+
+on:
+  push:
+    paths:
+      - "src/backend/base/**"
+      - "src/backend/tests/performance/**"
+    branches:
+      - "main" # or "master"
+  pull_request:
+    paths:
+      - "src/backend/base/**"
+      - "src/backend/tests/performance/**"
+      - "!src/backend/base/langflow/components/**"
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  codspeed:
+    name: Run benchmarks
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.12"
+    steps:
+      - name: Check out the code at a specific ref
+        uses: actions/checkout@v4
+      - name: "Setup Environment"
+        uses: ./.github/actions/setup-uv
+      - name: Run benchmarks
+        uses: CodSpeedHQ/action@v3
+        with:
+            token: ${{ secrets.CODSPEED_TOKEN }}
+            run: |
+              uv run pytest src/backend/tests \
+                --ignore=src/backend/tests/integration \
+                --codspeed \
+                -m "not api_key_required" \
+                -n auto
+      - name: Minimize uv cache
+        run: uv cache prune --ci

.github/workflows/conventional-labels.yml

@@ -0,0 +1,28 @@
+# Warning, do not check out untrusted code with
+# the pull_request_target event.
+name: Label PRs with Conventional Commits
+on:
+  pull_request_target:
+    types: [opened, edited]
+
+jobs:
+  validate-pr:
+    name: Validate PR
+    runs-on: ubuntu-latest
+    steps:
+      - name: Validate the pull request
+        id: validate
+        uses: Namchee/conventional-pr@v0.15.5
+        with:
+          access_token: ${{ secrets.GITHUB_TOKEN }}
+          issue: false
+
+  label:
+    needs: validate-pr
+    name: Label PR
+    runs-on: ubuntu-latest
+    if: ${{ github.event.pull_request.user.type != 'Bot'}}
+    steps:
+      - uses: bcoe/conventional-release-labels@v1
+        with:
+          type_labels: '{"feat": "enhancement","fix": "bug","docs": "documentation","style": "style","refactor": "refactor","perf": "performance","test": "test","chore": "chore","build": "build"}'

.github/workflows/create-release.yml

@@ -0,0 +1,36 @@
+name: Create Release
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "Version to release"
+        required: true
+        type: string
+      ref:
+        description: "Commit to tag the release"
+        required: true
+        type: string
+      pre_release:
+        description: "Pre-release tag"
+        required: true
+        type: boolean
+
+jobs:
+  create_release:
+    name: Create Release Job
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist-main
+          path: dist
+      - name: Create Release Notes
+        uses: ncipollo/release-action@v1
+        with:
+          artifacts: "dist/*"
+          token: ${{ secrets.GITHUB_TOKEN }}
+          draft: false
+          generateReleaseNotes: true
+          prerelease: ${{ inputs.pre_release }}
+          tag: v${{ inputs.version }}
+          commit: ${{ inputs.ref }}

.github/workflows/deploy_gh-pages.yml

@@ -0,0 +1,41 @@
+name: Deploy to GitHub Pages
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'docs/**'
+    # Review gh actions docs if you want to further define triggers, paths, etc
+    # https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#on
+
+jobs:
+  deploy:
+    name: Deploy to GitHub Pages
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 18
+          cache: npm
+          cache-dependency-path: ./docs/package-lock.json
+
+      - name: Install dependencies
+        run: cd docs && npm install --legacy-peer-deps
+      - name: Build website
+        run: cd docs && npm run build
+
+      # Popular action to deploy to GitHub Pages:
+      # Docs: https://github.com/peaceiris/actions-gh-pages#%EF%B8%8F-docusaurus
+      - name: Deploy to GitHub Pages
+        uses: peaceiris/actions-gh-pages@v4
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          # Build output to publish to the `gh-pages` branch:
+          publish_dir: ./docs/build
+          # The following lines assign commit authorship to the official
+          # GH-Actions bot for deploys to `gh-pages` branch:
+          # https://github.com/actions/checkout/issues/13#issuecomment-724415212
+          # The GH actions bot is used by default if you didn't specify the two fields.
+          # You can swap them out with your own user credentials.

.github/workflows/docker-build.yml

@@ -0,0 +1,323 @@
+name: Docker Build and Push
+run-name: Docker Build and Push @${{ inputs.release_type }} by @${{ github.actor }}
+on:
+  workflow_call:
+    inputs:
+      main_version:
+        required: true
+        type: string
+        description: "Main version to tag images with. Required for both main and base releases."
+      base_version:
+        required: false
+        type: string
+        description: "Base version to tag images with. Required for base release type."
+      release_type:
+        required: true
+        type: string
+        description: "Release type. One of 'main', 'main-ep', 'base', 'nightly-main', 'nightly-base'."
+      pre_release:
+        required: false
+        type: boolean
+        default: false
+      ref:
+        required: false
+        type: string
+        description: "Ref to check out. If not specified, will default to the main version or current branch."
+
+  workflow_dispatch:
+    inputs:
+      main_version:
+        description: "Main version to tag images with. Required for both main and base releases."
+        required: false
+        type: string
+      base_version:
+        description: "Base version to tag images with. Required for base release type."
+        required: false
+        type: string
+      release_type:
+        description: "Type of release. One of 'main', 'main-ep', 'base', 'nightly-main', 'nightly-base'."
+        required: true
+        type: string
+      pre_release:
+        required: false
+        type: boolean
+        default: false
+      ref:
+        required: false
+        type: string
+        description: "Ref to check out. If not specified, will default to the main version or current branch."
+
+
+env:
+  POETRY_VERSION: "1.8.2"
+  TEST_TAG: "langflowai/langflow:test"
+
+jobs:
+  get-version:
+    name: Get Version
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.get-version-input.outputs.version || steps.get-version-base.outputs.version || steps.get-version-main.outputs.version }}
+    steps:
+      - name: Verify a main version exists
+        if: ${{ inputs.main_version == '' }}
+        run: |
+          # due to our how we split packages, we need to have a main version to check out.
+          echo "Must specify a main version to check out."
+          exit 1
+
+      - name: Check out the code at a specific ref
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref || inputs.main_version || github.ref }}
+          persist-credentials: true
+
+      - name: Get Version to Tag
+        if: ${{ inputs.main_version != '' }}
+        id: get-version-input
+        run: |
+          # Produces the versions we will use to tag the docker images with.
+
+          if [[ "${{ inputs.release_type }}" == "base" && "${{ inputs.base_version }}" == '' ]]; then
+            echo "Must specify a base version for base release type."
+            exit 1
+          fi
+
+          if [[ "${{ inputs.release_type }}" == "nightly-base" && "${{ inputs.base_version }}" == '' ]]; then
+            echo "Must specify a base version for nightly-base release type."
+            exit 1
+          fi
+
+          if [[ "${{ inputs.release_type }}" == "main" && "${{ inputs.main_version }}" == '' ]]; then
+            echo "Must specify a main version for main release type."
+            exit 1
+          fi
+
+          if [[ "${{ inputs.release_type }}" == "main-ep" && "${{ inputs.main_version }}" == '' ]]; then
+            echo "Must specify a main version for main-ep release type."
+            exit 1
+          fi
+
+          if [[ "${{ inputs.release_type }}" == "nightly-main" && "${{ inputs.main_version }}" == '' ]]; then
+            echo "Must specify a main version for nightly-main release type."
+            exit 1
+          fi
+
+          if [[ "${{ inputs.release_type }}" == "base" || "${{ inputs.release_type }}" == "nightly-base" ]]; then
+            version=${{ inputs.base_version }}
+            echo "base version=${{ inputs.base_version }}"
+            echo version=$version
+            echo version=$version >> $GITHUB_OUTPUT
+          elif [[ "${{ inputs.release_type }}" == "main" || "${{ inputs.release_type }}" == "main-ep"  || "${{ inputs.release_type }}" == "nightly-main" ]]; then
+            version=${{ inputs.main_version }}
+            echo version=$version
+            echo version=$version >> $GITHUB_OUTPUT
+          else
+            echo "No version or ref specified. Exiting the workflow."
+            exit 1
+          fi
+      - name: Get Version Base
+        if: ${{ inputs.base_version == '' && (inputs.release_type == 'base' || inputs.release_type == 'nightly-base') }}
+        id: get-version-base
+        run: |
+          version=$(uv tree | grep 'langflow-base' | awk '{print $3}' | sed 's/^v//')
+          if [ -z "$version" ]; then
+            echo "Failed to extract version from uv tree output"
+            exit 1
+          fi
+          echo version=$version
+          echo version=$version >> $GITHUB_OUTPUT
+      - name: Get Version Main
+        if: ${{ inputs.main_version == '' && (inputs.release_type == 'main' || inputs.release_type == 'main-ep' || inputs.release_type == 'nightly-main') }}
+        id: get-version-main
+        run: |
+          version=$(uv tree | grep 'langflow' | grep -v 'langflow-base' | awk '{print $2}' | sed 's/^v//')
+          echo version=$version
+          echo version=$version >> $GITHUB_OUTPUT
+  setup:
+    runs-on: ubuntu-latest
+    needs: get-version
+    outputs:
+      docker_tags: ${{ steps.set-vars.outputs.docker_tags }}
+      ghcr_tags: ${{ steps.set-vars.outputs.ghcr_tags }}
+      file: ${{ steps.set-vars.outputs.file }}
+    steps:
+      - name: Set Dockerfile and Tags
+        id: set-vars
+        run: |
+          nightly_suffix=''
+          if [[ "${{ inputs.release_type }}" == "nightly-base" || "${{ inputs.release_type }}" == "nightly-main" ]]; then
+            nightly_suffix="-nightly"
+          fi
+
+          if [[ "${{ inputs.release_type }}" == "base" || "${{ inputs.release_type }}" == "nightly-base" ]]; then
+            # LANGFLOW-BASE RELEASE
+            echo "docker_tags=langflowai/langflow${nightly_suffix}:base-${{ needs.get-version.outputs.version }},langflowai/langflow${nightly_suffix}:base-latest" >> $GITHUB_OUTPUT
+            echo "ghcr_tags=ghcr.io/langflow-ai/langflow${nightly_suffix}:base-${{ needs.get-version.outputs.version }},ghcr.io/langflow-ai/langflow${nightly_suffix}:base-latest" >> $GITHUB_OUTPUT
+            echo "file=./docker/build_and_push_base.Dockerfile" >> $GITHUB_OUTPUT
+          else
+            if [[ "${{ inputs.pre_release }}" == "true" ]]; then
+              # LANGFLOW-MAIN PRE-RELEASE
+              echo "docker_tags=langflowai/langflow${nightly_suffix}:${{ needs.get-version.outputs.version }}" >> $GITHUB_OUTPUT
+              echo "ghcr_tags=ghcr.io/langflow-ai/langflow${nightly_suffix}:${{ needs.get-version.outputs.version }}" >> $GITHUB_OUTPUT
+              echo "file=./docker/build_and_push.Dockerfile" >> $GITHUB_OUTPUT
+            elif [[ "${{ inputs.release_type }}" == "main-ep" ]]; then
+              # LANGFLOW-MAIN (ENTRYPOINT) RELEASE
+              echo "docker_tags=langflowai/langflow-ep${nightly_suffix}:${{ needs.get-version.outputs.version }},langflowai/langflow-ep${nightly_suffix}:latest" >> $GITHUB_OUTPUT
+              echo "ghcr_tags=ghcr.io/langflow-ai/langflow-ep${nightly_suffix}:${{ needs.get-version.outputs.version }},ghcr.io/langflow-ai/langflow-ep${nightly_suffix}:latest" >> $GITHUB_OUTPUT
+              echo "file=./docker/build_and_push_ep.Dockerfile" >> $GITHUB_OUTPUT
+            elif [[ "${{ inputs.release_type }}" == "main" || "${{ inputs.release_type }}" == "nightly-main" ]]; then
+              # LANGFLOW-MAIN RELEASE
+              echo "docker_tags=langflowai/langflow${nightly_suffix}:${{ needs.get-version.outputs.version }},langflowai/langflow${nightly_suffix}:latest" >> $GITHUB_OUTPUT
+              echo "ghcr_tags=ghcr.io/langflow-ai/langflow${nightly_suffix}:${{ needs.get-version.outputs.version }},ghcr.io/langflow-ai/langflow${nightly_suffix}:latest" >> $GITHUB_OUTPUT
+              echo "file=./docker/build_and_push.Dockerfile" >> $GITHUB_OUTPUT
+            else
+              echo "Invalid release type. Exiting the workflow."
+              exit 1
+            fi
+          fi
+  build:
+    runs-on: ubuntu-latest
+    needs: [get-version, setup]
+    steps:
+      - name: Check out the code at a specific ref
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref || inputs.main_version || github.ref }}
+          persist-credentials: true
+      - name: "Setup Environment"
+        uses: ./.github/actions/setup-uv
+      - name: Install the project
+        run: |
+          if [[ "${{ inputs.release_type }}" == "base" || "${{ inputs.release_type }}" == "nightly-base" ]]; then
+            uv sync --directory src/backend/base --no-dev --no-sources
+          else
+            uv sync --no-dev --no-sources
+          fi
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and Push to Docker Hub
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          push: true
+          file: ${{ needs.setup.outputs.file }}
+          tags: ${{ needs.setup.outputs.docker_tags }}
+          platforms: linux/amd64,linux/arm64
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+      - name: Login to Github Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.TEMP_GHCR_TOKEN}}
+
+      - name: Build and push to Github Container Registry
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          push: true
+          file: ${{ needs.setup.outputs.file }}
+          tags: ${{ needs.setup.outputs.ghcr_tags }}
+          platforms: linux/amd64,linux/arm64
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+  build_components:
+    if: ${{ inputs.release_type == 'main' }}
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+    needs: [build, get-version]
+    strategy:
+      matrix:
+        component: [docker-backend, docker-frontend, ghcr-backend, ghcr-frontend]
+        include:
+          - component: docker-backend
+            dockerfile: ./docker/build_and_push_backend.Dockerfile
+            tags: langflowai/langflow-backend:${{ needs.get-version.outputs.version }},langflowai/langflow-backend:latest
+            langflow_image: langflowai/langflow:${{ needs.get-version.outputs.version }}
+          - component: docker-frontend
+            dockerfile: ./docker/frontend/build_and_push_frontend.Dockerfile
+            tags: langflowai/langflow-frontend:${{ needs.get-version.outputs.version }},langflowai/langflow-frontend:latest
+            langflow_image: langflowai/langflow:${{ needs.get-version.outputs.version }}
+          - component: ghcr-backend
+            dockerfile: ./docker/build_and_push_backend.Dockerfile
+            tags: ghcr.io/langflow-ai/langflow-backend:${{ needs.get-version.outputs.version }},ghcr.io/langflow-ai/langflow-backend:latest
+            langflow_image: ghcr.io/langflow-ai/langflow:${{ needs.get-version.outputs.version }}
+          - component: ghcr-frontend
+            dockerfile: ./docker/frontend/build_and_push_frontend.Dockerfile
+            tags: ghcr.io/langflow-ai/langflow-frontend:${{ needs.get-version.outputs.version }},ghcr.io/langflow-ai/langflow-frontend:latest
+            langflow_image: ghcr.io/langflow-ai/langflow:${{ needs.get-version.outputs.version }}
+    steps:
+      - name: Check out the code at a specific ref
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref || inputs.main_version || github.ref }}
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Docker Hub
+        if: ${{ matrix.component == 'docker-backend' }} || ${{ matrix.component == 'docker-frontend' }}
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Login to Github Container Registry
+        if: ${{ matrix.component == 'ghcr-backend' }} || ${{ matrix.component == 'ghcr-frontend' }}
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.TEMP_GHCR_TOKEN}}
+
+      - name: Wait for propagation (for backend)
+        run: sleep 120
+
+      - name: Build and push ${{ matrix.component }}
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          push: true
+          build-args: |
+            LANGFLOW_IMAGE=${{ matrix.langflow_image }}
+          file: ${{ matrix.dockerfile }}
+          tags: ${{ matrix.tags }}
+          # provenance: false will result in a single manifest for all platforms which makes the image pullable from arm64 machines via the emulation (e.g. Apple Silicon machines)
+          provenance: false
+
+  restart-space:
+    name: Restart HuggingFace Spaces
+    if: ${{ inputs.release_type == 'main' }}
+    runs-on: ubuntu-latest
+    needs: [build, get-version]
+    strategy:
+      matrix:
+        python-version:
+          - "3.12"
+    steps:
+      - name: Check out the code at a specific ref
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref || inputs.main_version || github.ref }}
+      - name: "Setup Environment"
+        uses: ./.github/actions/setup-uv
+
+      - name: Restart HuggingFace Spaces Build
+        run: |
+          uv run ./scripts/factory_restart_space.py --space "Langflow/Langflow" --token ${{ secrets.HUGGINGFACE_API_TOKEN }}
+
+
+

.github/workflows/docker_test.yml

@@ -0,0 +1,64 @@
+name: Test Docker images
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - "docker/**"
+      - "poetry.lock"
+      - "pyproject.toml"
+      - "src/backend/**"
+      - ".github/workflows/docker_test.yml"
+  pull_request:
+    branches: [dev]
+    paths:
+      - "docker/**"
+      - "poetry.lock"
+      - "pyproject.toml"
+      - "src/**"
+      - ".github/workflows/docker_test.yml"
+
+env:
+  POETRY_VERSION: "1.8.2"
+
+jobs:
+  test-docker:
+    runs-on: ubuntu-latest
+    name: Test docker images
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build image
+        run: |
+          docker build -t langflowai/langflow:latest-dev \
+            -f docker/build_and_push.Dockerfile \
+            .
+      - name: Test image
+        run: |
+          expected_version=$(cat pyproject.toml | grep version | head -n 1 | cut -d '"' -f 2)
+          version=$(docker run --rm --entrypoint bash langflowai/langflow:latest-dev -c "python -c 'from langflow.utils.version import get_version_info; print(get_version_info()[\"version\"])'")
+          if [ "$expected_version" != "$version" ]; then
+              echo "Expected version: $expected_version"
+              echo "Actual version: $version"
+              exit 1
+          fi
+
+      - name: Build backend image
+        run: |
+          docker build -t langflowai/langflow-backend:latest-dev \
+            --build-arg LANGFLOW_IMAGE=langflowai/langflow:latest-dev \
+            -f docker/build_and_push_backend.Dockerfile \
+            .
+      - name: Test backend image
+        run: |
+          expected_version=$(cat pyproject.toml | grep version | head -n 1 | cut -d '"' -f 2)
+          version=$(docker run --rm --entrypoint bash langflowai/langflow-backend:latest-dev -c "python -c 'from langflow.utils.version import get_version_info; print(get_version_info()[\"version\"])'")
+          if [ "$expected_version" != "$version" ]; then
+              echo "Expected version: $expected_version"
+              echo "Actual version: $version"
+              exit 1
+          fi
+      - name: Build frontend image
+        run: |
+          docker build -t langflowai/langflow-frontend:latest-dev \
+            -f docker/frontend/build_and_push_frontend.Dockerfile \
+            .

.github/workflows/docs_test.yml

@@ -0,0 +1,49 @@
+name: Test Docs Build
+
+on:
+  workflow_call:
+  workflow_dispatch:
+    inputs:
+      branch:
+        description: "(Optional) Branch to checkout"
+        required: false
+        type: string
+
+env:
+  NODE_VERSION: "21"
+
+jobs:
+  test-docs-build:
+    name: Test Docs Build
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.branch || github.ref }}
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        id: setup-node
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+
+      - name: Cache Node.js dependencies
+        uses: actions/cache@v4
+        id: npm-cache
+        with:
+          path: ~/.npm
+          key: ${{ runner.os }}-node-${{ hashFiles('docs/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-node-
+
+      - name: Install Node.js dependencies
+        run: |
+          cd docs
+          npm install --legacy-peer-deps
+        if: ${{ steps.setup-node.outputs.cache-hit != 'true' }}
+
+      - name: Build Docs
+        run: |
+          cd docs
+          npm run build

.github/workflows/fetch_docs_notion.yml

@@ -0,0 +1,61 @@
+name: Fetch Docs from Notion
+
+on:
+  workflow_dispatch:
+
+env:
+  NODE_VERSION: "21"
+
+jobs:
+  fetch-docs:
+    name: Fetch Docs from Notion
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Get current date
+        id: date
+        run: echo "DATE=$(date +'%Y%m%d%H%M%S')" >> "$GITHUB_OUTPUT"
+
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        id: setup-node
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+
+      - name: Cache Node.js dependencies
+        uses: actions/cache@v4
+        id: npm-cache
+        with:
+          path: ~/.npm
+          key: ${{ runner.os }}-node-${{ hashFiles('docs/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-node-
+
+      - name: Install Node.js dependencies
+        run: |
+          cd docs
+          npm install --legacy-peer-deps
+        if: ${{ steps.setup-node.outputs.cache-hit != 'true' }}
+
+      - name: Fetch Docs from Notion
+        run: |
+          cd docs
+          npm run pull
+        env:
+          NOTION_TOKEN: ${{ secrets.NOTION_TOKEN }}
+          NOTION_DOCS_ROOT_PAGE_ID: ${{ secrets.NOTION_DOCS_ROOT_PAGE_ID }}
+
+      - name: Create Pull Request
+        id: create_pr
+        uses: peter-evans/create-pull-request@v7
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          commit-message: Update docs from Notion
+          branch: update-docs-${{ steps.date.outputs.DATE }}
+          base: main
+          title: "docs: update docs from notion"
+          body: This PR updates the documentation from Notion.
+          labels: documentation

.github/workflows/integration_tests.yml

@@ -0,0 +1,50 @@
+name: Integration Tests
+
+on:
+  workflow_dispatch:
+    inputs:
+      ref:
+        description: "(Optional) ref to checkout"
+        required: false
+        type: string
+  workflow_call:
+    inputs:
+      python-versions:
+        description: "(Optional) Python versions to test"
+        required: true
+        type: string
+        default: "['3.10', '3.11', '3.12']"
+      ref:
+        description: "(Optional) ref to checkout"
+        required: false
+        type: string
+
+env:
+  POETRY_VERSION: "1.8.2"
+
+jobs:
+  integration-tests:
+    name: Run Integration Tests
+    runs-on: ubuntu-latest
+    strategy:
+      max-parallel: 1 # Currently, we can only run at a time for collection-per-db-constraints
+      matrix:
+        python-version:
+          - "3.12"
+          - "3.11"
+          - "3.10"
+    env:
+      OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+      ASTRA_DB_API_ENDPOINT: ${{ secrets.ASTRA_DB_API_ENDPOINT }}
+      ASTRA_DB_APPLICATION_TOKEN: ${{ secrets.ASTRA_DB_APPLICATION_TOKEN }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref || github.ref }}
+      - name: "Setup Environment"
+        uses: ./.github/actions/setup-uv
+      - name: Run integration tests with api keys
+        timeout-minutes: 20
+        run: |
+          make integration_tests_api_keys

.github/workflows/js_autofix.yml

@@ -0,0 +1,45 @@
+name: autofix.ci
+
+on:
+  pull_request:
+    paths:
+      - "src/frontend/**"
+
+permissions:
+  contents: read
+
+env:
+  NODE_VERSION: "21"
+jobs:
+  autofix:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        id: setup-node
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+
+      - name: Cache Node.js dependencies
+        uses: actions/cache@v4
+        id: npm-cache
+        with:
+          path: ~/.npm
+          key: ${{ runner.os }}-node-${{ hashFiles('src/frontend/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-node-
+
+      - name: Install Node.js dependencies
+        run: |
+          cd src/frontend
+          npm ci
+        if: ${{ steps.setup-node.outputs.cache-hit != 'true' }}
+      - name: Run Prettier
+        run: |
+          cd src/frontend
+          npm run format
+
+      - uses: autofix-ci/action@ff86a557419858bb967097bfc916833f5647fa8c

.github/workflows/lint-js.yml

@@ -0,0 +1,53 @@
+name: Lint Frontend
+
+on:
+  workflow_call:
+  workflow_dispatch:
+    inputs:
+      branch:
+        description: "(Optional) Branch to checkout"
+        required: false
+        type: string
+
+
+env:
+  NODE_VERSION: "21"
+
+jobs:
+  run-linters:
+    name: Run Prettier
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.branch || github.ref }}
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        id: setup-node
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+
+      - name: Cache Node.js dependencies
+        uses: actions/cache@v4
+        id: npm-cache
+        with:
+          path: ~/.npm
+          key: ${{ runner.os }}-node-${{ hashFiles('src/frontend/package-lock.json') }}
+          restore-keys: |
+            ${{ runner.os }}-node-
+
+      - name: Install Node.js dependencies
+        run: |
+          cd src/frontend
+          npm install
+        if: ${{ steps.setup-node.outputs.cache-hit != 'true' }}
+
+      - name: Run Prettier
+        run: |
+          cd src/frontend
+          npm run check-format

.github/workflows/lint-py.yml

@@ -0,0 +1,41 @@
+name: Lint Python
+
+on:
+  workflow_call:
+  workflow_dispatch:
+    inputs:
+      branch:
+        description: "(Optional) Branch to checkout"
+        required: false
+        type: string
+env:
+  POETRY_VERSION: "1.8.2"
+
+
+jobs:
+  lint:
+    name: Run Mypy
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.12"
+          - "3.11"
+          - "3.10"
+    steps:
+      - name: Check out the code at a specific ref
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.branch || github.ref }}
+          persist-credentials: true
+      - name: "Setup Environment"
+        uses: ./.github/actions/setup-uv
+      - name: Install the project
+        run: uv sync --dev
+      - name: Run Mypy
+        run: |
+          uv run mypy --namespace-packages -p "langflow"
+        env:
+          GITHUB_TOKEN: ${{ secrets.github_token }}
+      - name: Minimize uv cache
+        run: uv cache prune --ci

.github/workflows/matchers/ruff.json

@@ -0,0 +1,14 @@
+{
+    "problemMatcher": [
+        {
+            "owner": "ruff",
+            "pattern": [
+                {
+                    "regexp": "^(Would reformat): (.+)$",
+                    "message": 1,
+                    "file": 2
+                }
+            ]
+        }
+    ]
+}

.github/workflows/nightly_build.yml

@@ -0,0 +1,204 @@
+name: Nightly Build
+
+on:
+  workflow_dispatch:
+  schedule:
+    # Run job at 6:30 UTC, 10.30pm PST, or 11.30pm PDT
+    - cron: "30 6 * * *"
+
+env:
+  POETRY_VERSION: "1.8.3"
+  PYTHON_VERSION: "3.12"
+
+jobs:
+  create-nightly-tag:
+    if: github.repository == 'langflow-ai/langflow'
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash -ex -o pipefail {0}
+    permissions:
+      # Required to create tag
+      contents: write
+    outputs:
+      main_tag: ${{ steps.generate_main_tag.outputs.main_tag }}
+      base_tag: ${{ steps.set_base_tag.outputs.base_tag }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          persist-credentials: true
+      - name: "Setup Environment"
+        uses: ./.github/actions/setup-uv
+      - name: Install the project
+        run: uv sync --dev
+
+      - name: Generate main nightly tag
+        id: generate_main_tag
+        run: |
+          # NOTE: This outputs the tag with the `v` prefix.
+          MAIN_TAG="$(uv run ./scripts/ci/pypi_nightly_tag.py main)"
+          echo "main_tag=$MAIN_TAG" >> $GITHUB_OUTPUT
+          echo "main_tag=$MAIN_TAG"
+
+      - name: Check if main tag already exists
+        id: check_main_tag
+        run: |
+          git fetch --tags
+          if git rev-parse -q --verify "refs/tags/${{ steps.generate_main_tag.outputs.main_tag }}" >/dev/null; then
+            echo "main_tag_exists=true" >> $GITHUB_OUTPUT
+          else
+            echo "main_tag_exists=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Generate base nightly tag
+        id: generate_base_tag
+        if: ${{ steps.check_main_tag.outputs.main_tag_exists == 'false' }}
+        run: |
+          # NOTE: This outputs the tag with the `v` prefix.
+          BASE_TAG="$(uv run ./scripts/ci/pypi_nightly_tag.py base)"
+          echo "base_tag=$BASE_TAG" >> $GITHUB_OUTPUT
+          echo "base_tag=$BASE_TAG"
+
+      - name: Commit tag
+        id: commit_tag
+        if: ${{ steps.check_main_tag.outputs.main_tag_exists == 'false' }}
+        run: |
+          # If the main tag does not exist in GH, we create the base tag from the existing codebase.
+
+          git config --global user.email "bot-nightly-builds@langflow.org"
+          git config --global user.name "Langflow Bot"
+
+          MAIN_TAG="${{ steps.generate_main_tag.outputs.main_tag }}"
+          BASE_TAG="${{ steps.generate_base_tag.outputs.base_tag }}"
+          echo "Updating base project version to $BASE_TAG and updating main project version to $MAIN_TAG"
+          uv run ./scripts/ci/update_pyproject_combined.py main $MAIN_TAG $BASE_TAG
+
+          uv lock
+          cd src/backend/base && uv lock && cd ../../..
+
+          git add pyproject.toml src/backend/base/pyproject.toml uv.lock src/backend/base/uv.lock
+          git commit -m "Update version and project name"
+
+          echo "Tagging main with $MAIN_TAG"
+          if ! git tag -a $MAIN_TAG -m "Langflow nightly $MAIN_TAG"; then
+            echo "Tag creation failed. Exiting the workflow."
+            exit 1
+          fi
+
+          echo "Pushing main tag $MAIN_TAG"
+          if ! git push origin $MAIN_TAG; then
+            echo "Tag push failed. Check if the tag already exists. Exiting the workflow."
+            exit 1
+          fi
+          # TODO: notify on failure
+
+      - name: Checkout main nightly tag
+        uses: actions/checkout@v4
+        if: ${{ steps.check_main_tag.outputs.main_tag_exists == 'true' }}
+        with:
+          ref: ${{ steps.generate_main_tag.outputs.main_tag }}
+
+      - name: Retrieve Base Tag
+        id: retrieve_base_tag
+        if: ${{ steps.check_main_tag.outputs.main_tag_exists == 'true' }}
+        working-directory: src/backend/base
+        run: |
+          # If the main tag already exists, we need to retrieve the base version from the main tag codebase.
+          version=$(uv tree | grep 'langflow-base' | awk '{print $3}')
+          echo "base_tag=$version" >> $GITHUB_OUTPUT
+          echo "base_tag=$version"
+
+      - name: Set Base Tag
+        id: set_base_tag
+        run: |
+          if [ "${{ steps.retrieve_base_tag.conclusion }}" != "skipped" ] && [ "${{ steps.retrieve_base_tag.outputs.base_tag }}" ]; then
+            BASE_TAG="${{ steps.retrieve_base_tag.outputs.base_tag }}"
+            echo "base_tag=$BASE_TAG" >> $GITHUB_OUTPUT
+            echo "base_tag=$BASE_TAG"
+          elif [ "${{ steps.commit_tag.conclusion }}" != "skipped" ] && [ "${{ steps.generate_base_tag.outputs.base_tag }}" ]; then
+            BASE_TAG="${{ steps.generate_base_tag.outputs.base_tag }}"
+            echo "base_tag=$BASE_TAG" >> $GITHUB_OUTPUT
+            echo "base_tag=$BASE_TAG"
+          else
+            echo "No base tag found. Exiting the workflow."
+            exit 1
+          fi
+
+  frontend-tests:
+    if: github.repository == 'langflow-ai/langflow'
+    name: Run Frontend Tests
+    needs: create-nightly-tag
+    uses: ./.github/workflows/typescript_test.yml
+    with:
+      tests_folder: "tests"
+      release: true
+    secrets:
+      OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+      STORE_API_KEY: ${{ secrets.STORE_API_KEY }}
+      ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+      TAVILY_API_KEY: ${{ secrets.TAVILY_API_KEY }}
+
+  backend-unit-tests:
+    if: github.repository == 'langflow-ai/langflow'
+    name: Run Backend Unit Tests
+    needs: create-nightly-tag
+    uses: ./.github/workflows/python_test.yml
+    with:
+      python-versions: '["3.10", "3.11", "3.12"]'
+
+  # Not making nightly builds dependent on integration test success
+  # due to inherent flakiness of 3rd party integrations
+  # Revisit when https://github.com/langflow-ai/langflow/pull/3607 is merged.
+  # backend-integration-tests:
+  #   name: Run Backend Integration Tests
+  #   needs: create-nightly-tag
+  #   uses: ./.github/workflows/integration_tests.yml
+  #   with:
+  #     python-versions: '["3.10", "3.11", "3.12"]'
+  #     ref: ${{ needs.create-nightly-tag.outputs.tag }}
+
+  release-nightly-build:
+    if: github.repository == 'langflow-ai/langflow'
+    name: Run Nightly Langflow Build
+    needs: [frontend-tests, backend-unit-tests, create-nightly-tag]
+    uses: ./.github/workflows/release_nightly.yml
+    with:
+      build_docker_base: true
+      build_docker_main: true
+      nightly_tag_main: ${{ needs.create-nightly-tag.outputs.main_tag }}
+      nightly_tag_base: ${{ needs.create-nightly-tag.outputs.base_tag }}
+    secrets: inherit
+
+  # slack-notification:
+  #   name: Send Slack Notification
+  #   needs: run-nightly-build
+  #   runs-on: ubuntu-latest
+  #   steps:
+  #     - name: Send success notification to Slack
+  #       if: success()
+  #       uses: slackapi/slack-github-action@v1.26.0
+  #       with:
+  #         payload: |
+  #           {
+  #             "channel": "#langflow-nightly-builds",
+  #             "username": "GitHub Actions",
+  #             "text": "Nightly Build Successful :white_check_mark:",
+  #             "icon_emoji": ":rocket:"
+  #           }
+  #       env:
+  #         SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
+
+  #     - name: Send failure notification to Slack
+  #       if: failure()
+  #       uses: slackapi/slack-github-action@v1.26.0
+  #       with:
+  #         payload: |
+  #           {
+  #             "channel": "#langflow-nightly-builds",
+  #             "username": "GitHub Actions",
+  #             "text": "Nightly Build Failed :x:",
+  #             "icon_emoji": ":warning:"
+  #           }
+  #       env:
+  #         SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}

.github/workflows/py_autofix.yml

@@ -0,0 +1,21 @@
+name: autofix.ci
+on:
+  pull_request:
+    paths:
+      - "**/*.py"
+env:
+  POETRY_VERSION: "1.8.2"
+
+jobs:
+  lint:
+    name: Run Ruff Check and Format
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: "Setup Environment"
+        uses: ./.github/actions/setup-uv
+      - run: uv run ruff check --fix-only .
+      - run: uv run ruff format .
+      - uses: autofix-ci/action@ff86a557419858bb967097bfc916833f5647fa8c
+      - name: Minimize uv cache
+        run: uv cache prune --ci

.github/workflows/python_test.yml

@@ -0,0 +1,175 @@
+name: Python tests
+
+on:
+  workflow_call:
+    inputs:
+      python-versions:
+        description: "(Optional) Python versions to test"
+        required: true
+        type: string
+        default: "['3.10', '3.11', '3.12']"
+      ref:
+        description: "(Optional) ref to checkout"
+        required: false
+        type: string
+      nightly:
+        description: "Whether run is from the nightly build"
+        required: false
+        type: boolean
+        default: false
+  workflow_dispatch:
+    inputs:
+      python-versions:
+        description: "(Optional) Python versions to test"
+        required: true
+        type: string
+        default: "['3.10', '3.11', '3.12']"
+env:
+  POETRY_VERSION: "1.8.2"
+  NODE_VERSION: "21"
+  PYTEST_RUN_PATH: "src/backend/tests"
+
+jobs:
+  build:
+    name: Unit Tests - Python ${{ matrix.python-version }} - Group ${{ matrix.group }}
+    runs-on: ubuntu-latest
+    env:
+      UV_CACHE_DIR: /tmp/.uv-cache
+    strategy:
+      matrix:
+        python-version: ${{ fromJson(inputs.python-versions || '["3.10", "3.11", "3.12"]' ) }}
+        splitCount: [5]
+        group: [1, 2, 3, 4, 5]
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref || github.ref }}
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        id: setup-node
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+        with:
+          enable-cache: true
+          cache-dependency-glob: "uv.lock"
+      - name: "Set up Python"
+        uses: actions/setup-python@v5
+        with:
+          python-version-file: "pyproject.toml"
+      - name: Restore uv cache
+        uses: actions/cache@v4
+        with:
+          path: /tmp/.uv-cache
+          key: uv-${{ runner.os }}-${{ hashFiles('uv.lock') }}
+          restore-keys: |
+            uv-${{ runner.os }}-${{ hashFiles('uv.lock') }}
+            uv-${{ runner.os }}
+      - name: Install the project
+        run: uv sync --dev
+      - name: Run unit tests
+        uses: nick-fields/retry@v3
+        with:
+          timeout_minutes: 12
+          max_attempts: 2
+          command: make unit_tests async=false args="-x --splits ${{ matrix.splitCount }} --group ${{ matrix.group }}"
+      - name: Minimize uv cache
+        run: uv cache prune --ci
+  integration-tests:
+    name: Integration Tests - Python ${{ matrix.python-version }}
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ${{ fromJson(inputs.python-versions || '["3.10", "3.11", "3.12"]' ) }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref || github.ref }}
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+        with:
+          enable-cache: true
+          cache-dependency-glob: "uv.lock"
+      - name: "Set up Python"
+        uses: actions/setup-python@v5
+        with:
+          python-version-file: "pyproject.toml"
+      - name: Restore uv cache
+        uses: actions/cache@v4
+        with:
+          path: /tmp/.uv-cache
+          key: uv-${{ runner.os }}-${{ hashFiles('uv.lock') }}
+          restore-keys: |
+            uv-${{ runner.os }}-${{ hashFiles('uv.lock') }}
+            uv-${{ runner.os }}
+      - name: Install the project
+        run: uv sync --dev
+      - name: Run integration tests
+        run: make integration_tests_no_api_keys
+      - name: Minimize uv cache
+        run: uv cache prune --ci
+  test-cli:
+    name: Test CLI - Python ${{ matrix.python-version }}
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ${{ fromJson(inputs.python-versions || '["3.10", "3.11", "3.12"]') }}
+    steps:
+      - name: Check out the code at a specific ref
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref || github.ref }}
+      - name: "Setup Environment"
+        uses: ./.github/actions/setup-uv
+
+      - name: Check Version
+        id: check-version
+        # We need to print $3 because langflow-base is a dependency of langflow
+        # For langlow we'd use print $2
+        run: |
+          version=$(uv tree | grep 'langflow-base' | awk '{print $3}' | sed 's/^v//')
+          url="https://pypi.org/pypi/langflow-base/json"
+          if [ ${{ inputs.nightly }} == true ]; then
+            url="https://pypi.org/pypi/langflow-base-nightly/json"
+          fi
+
+          last_released_version=$(curl -s $url | jq -r '.releases | keys | .[]' | sort -V | tail -n 1)
+          if [ "$version" != "$last_released_version" ]; then
+            echo "Version $version has not been released yet. Skipping the rest of the job."
+            echo skipped=true >> $GITHUB_OUTPUT
+            exit 0
+          else
+            echo version=$version >> $GITHUB_OUTPUT
+            echo skipped=false >> $GITHUB_OUTPUT
+          fi
+      - name: Build wheel
+        if: steps.check-version.outputs.skipped == 'false'
+        run: |
+          make build main=true
+      - name: Install wheel and Test CLI
+        if: steps.check-version.outputs.skipped == 'false'
+        run: |
+          uv venv new-venv
+          source new-venv/bin/activate
+          uv pip install dist/*.whl
+      - name: Test CLI
+        if: steps.check-version.outputs.skipped == 'false'
+        run: |
+          source new-venv/bin/activate
+          python -m langflow run --host 127.0.0.1 --port 7860 --backend-only &
+          SERVER_PID=$!
+          # Wait for the server to start
+          timeout 120 bash -c 'until curl -f http://127.0.0.1:7860/api/v1/auto_login; do sleep 5; done' || (echo "Server did not start in time" && kill $SERVER_PID && exit 1)
+          # Terminate the server
+          kill $SERVER_PID || (echo "Failed to terminate the server" && exit 1)
+          sleep 20 # give the server some time to terminate
+          # Check if the server is still running
+          if kill -0 $SERVER_PID 2>/dev/null; then
+            echo "Failed to terminate the server"
+            exit 0
+          else
+            echo "Server terminated successfully"
+          fi
+      - name: Minimize uv cache
+        run: uv cache prune --ci

.github/workflows/release.yml

@@ -0,0 +1,243 @@
+name: Langflow Release
+run-name: Langflow Release by @${{ github.actor }}
+
+on:
+  workflow_dispatch:
+    inputs:
+      release_package_base:
+        description: "Release Langflow Base"
+        required: true
+        type: boolean
+        default: false
+      release_package_main:
+        description: "Release Langflow"
+        required: true
+        type: boolean
+        default: false
+      build_docker_base:
+        description: "Build Docker Image for Langflow Base"
+        required: true
+        type: boolean
+        default: false
+      build_docker_main:
+        description: "Build Docker Image for Langflow"
+        required: true
+        type: boolean
+        default: false
+      build_docker_ep:
+        description: "Build Docker Image for Langflow with Entrypoint"
+        required: false
+        type: boolean
+        default: false
+      pre_release:
+        description: "Pre-release"
+        required: false
+        type: boolean
+        default: false
+      create_release:
+        description: "Whether to create a gh release"
+        required: false
+        type: boolean
+        default: true
+
+
+jobs:
+  ci:
+    if: ${{ github.event.inputs.release_package_base == 'true' || github.event.inputs.release_package_main == 'true' }}
+    name: CI
+    uses: ./.github/workflows/ci.yml
+    with:
+      python-versions: "['3.10', '3.11', '3.12']"
+      frontend-tests-folder: "tests"
+      release: true
+
+  release-base:
+    name: Release Langflow Base
+    needs: [ci]
+    if: inputs.release_package_base == true
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.check-version.outputs.version }}
+      skipped: ${{ steps.check-version.outputs.skipped }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Setup Environment
+        uses: ./.github/actions/setup-uv
+      - name: Install the project
+        run: uv sync --dev
+      - name: Check Version
+        id: check-version
+        run: |
+          version=$(uv tree | grep 'langflow-base' | awk '{print $3}' | sed 's/^v//')
+          last_released_version=$(curl -s "https://pypi.org/pypi/langflow-base/json" | jq -r '.releases | keys | .[]' | sort -V | tail -n 1)
+          if [ "$version" = "$last_released_version" ]; then
+            echo "Version $version is already released. Skipping release."
+            echo skipped=true >> $GITHUB_OUTPUT
+            exit 0
+          else
+            echo version=$version >> $GITHUB_OUTPUT
+            echo skipped=false >> $GITHUB_OUTPUT
+          fi
+      - name: Build project for distribution
+        if: steps.check-version.outputs.skipped == 'false'
+        run: make build base=true args="--wheel"
+      - name: Test CLI
+        if: steps.check-version.outputs.skipped == 'false'
+        run: |
+          # TODO: Unsure why the whl is not built in src/backend/base/dist
+          mkdir src/backend/base/dist
+          mv dist/*.whl src/backend/base/dist
+          uv pip install src/backend/base/dist/*.whl
+          uv run python -m langflow run --host 127.0.0.1 --port 7860 --backend-only &
+          SERVER_PID=$!
+          # Wait for the server to start
+          timeout 120 bash -c 'until curl -f http://127.0.0.1:7860/api/v1/auto_login; do sleep 2; done' || (echo "Server did not start in time" && kill $SERVER_PID && exit 1)
+          # Terminate the server
+          kill $SERVER_PID || (echo "Failed to terminate the server" && exit 1)
+          sleep 20 # give the server some time to terminate
+          # Check if the server is still running
+          if kill -0 $SERVER_PID 2>/dev/null; then
+            echo "Failed to terminate the server"
+            exit 0
+          else
+            echo "Server terminated successfully"
+          fi
+      - name: Publish to PyPI
+        if: steps.check-version.outputs.skipped == 'false'
+        env:
+          UV_PUBLISH_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
+        run: |
+          make publish base=true
+      - name: Upload Artifact
+        if: steps.check-version.outputs.skipped == 'false'
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist-base
+          path: src/backend/base/dist
+
+  release-main:
+    name: Release Langflow Main
+    if: inputs.release_package_main == true
+    needs: [release-base]
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.check-version.outputs.version }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Setup Environment
+        uses: ./.github/actions/setup-uv
+      - name: Install the project
+        run: uv sync --dev
+
+      # If pre-release is true, we need to check if  ["a", "b", "rc", "dev", "post"] is in the version string
+      # if the version string is incorrect, we need to exit the workflow
+      - name: Check if pre-release
+        if: inputs.pre_release == 'true'
+        run: |
+          version=$(uv tree | grep 'langflow' | grep -v 'langflow-base' | awk '{print $2}' | sed 's/^v//')
+          if [[ "${version}" =~ ^([0-9]+\.)?([0-9]+\.)?[0-9]+((a|b|rc|dev|post)([0-9]+))$ ]]; then
+            echo "Pre-release version detected. Continuing with the release."
+          else
+            echo "Invalid pre-release version detected. Exiting the workflow."
+            exit 1
+          fi
+      - name: Check Version
+        id: check-version
+        run: |
+          version=$(uv tree | grep 'langflow' | grep -v 'langflow-base' | awk '{print $2}' | sed 's/^v//')
+          last_released_version=$(curl -s "https://pypi.org/pypi/langflow/json" | jq -r '.releases | keys | .[]' | sort -V | tail -n 1)
+          if [ "$version" = "$last_released_version" ]; then
+            echo "Version $version is already released. Skipping release."
+            exit 1
+          else
+            echo version=$version >> $GITHUB_OUTPUT
+          fi
+      - name: Wait for PyPI Propagation
+        if: needs.release-base.outputs.skipped == 'false'
+        run: sleep 300 # wait for 5 minutes to ensure PyPI propagation
+
+      - name: Build project for distribution
+        run: make build main=true args="--no-sources --wheel"
+      - name: Test CLI
+        run: |
+          uv pip install dist/*.whl
+          uv run python -m langflow run --host 127.0.0.1 --port 7860 --backend-only &
+          SERVER_PID=$!
+          # Wait for the server to start
+          timeout 120 bash -c 'until curl -f http://127.0.0.1:7860/health_check; do sleep 2; done' || (echo "Server did not start in time" && kill $SERVER_PID && exit 1)
+          # Terminate the server
+          kill $SERVER_PID || (echo "Failed to terminate the server" && exit 1)
+          sleep 20 # give the server some time to terminate
+          # Check if the server is still running
+          if kill -0 $SERVER_PID 2>/dev/null; then
+            echo "Failed to terminate the server"
+            exit 0
+          else
+            echo "Server terminated successfully"
+          fi
+      - name: Publish to PyPI
+        env:
+          UV_PUBLISH_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
+        run: |
+          make publish main=true
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist-main
+          path: dist
+
+  call_docker_build_base:
+    name: Call Docker Build Workflow for Langflow Base
+    if: inputs.build_docker_base == true
+    needs: [release-base, release-main]
+    uses: ./.github/workflows/docker-build.yml
+    with:
+      base_version: ${{ needs.release-base.outputs.version }}
+      main_version: ${{ needs.release-main.outputs.version }}
+      release_type: base
+      pre_release: ${{ inputs.pre_release }}
+    secrets: inherit
+
+  call_docker_build_main:
+    name: Call Docker Build Workflow for Langflow
+    if: inputs.build_docker_main == true
+    needs: [release-main]
+    uses: ./.github/workflows/docker-build.yml
+    with:
+      main_version: ${{ needs.release-main.outputs.version }}
+      release_type: main
+      pre_release: ${{ inputs.pre_release }}
+    secrets: inherit
+
+  call_docker_build_main_ep:
+    name: Call Docker Build Workflow for Langflow with Entrypoint
+    if: inputs.build_docker_ep == true
+    needs: [release-main]
+    uses: ./.github/workflows/docker-build.yml
+    with:
+      main_version: ${{ needs.release-main.outputs.version }}
+      release_type: main-ep
+      pre_release: False
+    secrets: inherit
+
+  create_release:
+    name: Create Release
+    runs-on: ubuntu-latest
+    needs: release-main
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist-main
+          path: dist
+      - name: Create Release
+        uses: ncipollo/release-action@v1
+        with:
+          artifacts: "dist/*"
+          token: ${{ secrets.GITHUB_TOKEN }}
+          draft: false
+          generateReleaseNotes: true
+          prerelease: ${{ inputs.pre_release }}
+          tag: ${{ needs.release-main.outputs.version }}
+          commit: ${{ github.ref }}

.github/workflows/release_nightly.yml

@@ -0,0 +1,233 @@
+name: Langflow Nightly Build
+run-name: Langflow Nightly Release by @${{ github.actor }}
+
+on:
+  workflow_dispatch:
+    inputs:
+      build_docker_base:
+        description: "Build Docker Image for Langflow Nightly Base"
+        required: true
+        type: boolean
+        default: false
+      build_docker_main:
+        description: "Build Docker Image for Langflow Nightly"
+        required: true
+        type: boolean
+        default: false
+      build_docker_ep:
+        description: "Build Docker Image for Langflow Nightly with Entrypoint"
+        required: false
+        type: boolean
+        default: false
+      nightly_tag_main:
+        description: "Tag for the nightly main build"
+        required: true
+        type: string
+      nightly_tag_base:
+        description: "Tag for the nightly base build"
+        required: true
+        type: string
+  workflow_call:
+    inputs:
+      build_docker_base:
+        description: "Build Docker Image for Langflow Nightly Base"
+        required: true
+        type: boolean
+        default: false
+      build_docker_main:
+        description: "Build Docker Image for Langflow Nightly"
+        required: true
+        type: boolean
+        default: false
+      build_docker_ep:
+        description: "Build Docker Image for Langflow Nightly with Entrypoint"
+        required: false
+        type: boolean
+        default: false
+      nightly_tag_main:
+        description: "Tag for the nightly main build"
+        required: true
+        type: string
+      nightly_tag_base:
+        description: "Tag for the nightly base build"
+        required: true
+        type: string
+
+env:
+  POETRY_VERSION: "1.8.3"
+  PYTHON_VERSION: "3.12"
+
+jobs:
+  release-nightly-base:
+    name: Release Langflow Nightly Base
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        shell: bash
+    outputs:
+      version: ${{ steps.verify.outputs.version }}
+    steps:
+      - name: Check out the code at a specific ref
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.nightly_tag_main }}
+          persist-credentials: true
+      - name: "Setup Environment"
+        uses: ./.github/actions/setup-uv
+      - name: Install the project
+        run: uv sync --dev
+
+      - name: Verify Nightly Name and Version
+        id: verify
+        run: |
+          name=$(uv tree | grep 'langflow-base' | awk '{print $2}')
+          version=$(uv tree | grep 'langflow-base' | awk '{print $3}')
+          if [ "$name" != "langflow-base-nightly" ]; then
+            echo "Name $name does not match langflow-base-nightly. Exiting the workflow."
+            exit 1
+          fi
+          if [ "$version" != "${{ inputs.nightly_tag_base }}" ]; then
+            echo "Version $version does not match nightly tag ${{ inputs.nightly_tag_base }}. Exiting the workflow."
+            exit 1
+          fi
+          # Strip the leading `v` from the version
+          version=$(echo $version | sed 's/^v//')
+          echo "version=$version" >> $GITHUB_OUTPUT
+
+      - name: Build project for distribution
+        run: make build base=true args="--wheel"
+
+      - name: Test CLI
+        run: |
+          # TODO: Unsure why the whl is not built in src/backend/base/dist
+          mkdir src/backend/base/dist
+          mv dist/*.whl src/backend/base/dist/
+          uv pip install src/backend/base/dist/*.whl
+          uv run python -m langflow run --host 127.0.0.1 --port 7860 --backend-only &
+          SERVER_PID=$!
+          # Wait for the server to start
+          timeout 120 bash -c 'until curl -f http://127.0.0.1:7860/api/v1/auto_login; do sleep 2; done' || (echo "Server did not start in time" && kill $SERVER_PID && exit 1)
+          # Terminate the server
+          kill $SERVER_PID || (echo "Failed to terminate the server" && exit 1)
+          sleep 20 # give the server some time to terminate
+          # Check if the server is still running
+          if kill -0 $SERVER_PID 2>/dev/null; then
+            echo "Failed to terminate the server"
+            exit 0
+          else
+            echo "Server terminated successfully"
+          fi
+
+      - name: Publish to PyPI
+        env:
+          POETRY_PYPI_TOKEN_PYPI: ${{ secrets.PYPI_API_TOKEN }}
+          UV_PUBLISH_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
+        run: |
+          make publish base=true
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist-base
+          path: src/backend/base/dist
+
+  release-nightly-main:
+    name: Release Langflow Nightly Main
+    needs: [release-nightly-base]
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.verify.outputs.version }}
+    defaults:
+      run:
+        shell: bash
+    steps:
+      - name: Check out the code at a specific ref
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.nightly_tag_main}}
+          persist-credentials: true
+      - name: "Setup Environment"
+        uses: ./.github/actions/setup-uv
+      - name: Install the project
+        run: uv sync --dev
+
+      - name: Verify Nightly Name and Version
+        id: verify
+        run: |
+          name=$(uv tree | grep 'langflow' | grep -v 'langflow-base' | awk '{print $1}')
+          version=$(uv tree | grep 'langflow' | grep -v 'langflow-base' | awk '{print $2}')
+          if [ "$name" != "langflow-nightly" ]; then
+            echo "Name $name does not match langflow-nightly. Exiting the workflow."
+            exit 1
+          fi
+          if [ "$version" != "${{ inputs.nightly_tag_main }}" ]; then
+            echo "Version $version does not match nightly tag ${{ inputs.nightly_tag_main }}. Exiting the workflow."
+            exit 1
+          fi
+          # Strip the leading `v` from the version
+          version=$(echo $version | sed 's/^v//')
+          echo "version=$version" >> $GITHUB_OUTPUT
+      - name: Wait for PyPI Propagation
+        run: sleep 300 # wait for 5 minutes to ensure PyPI propagation of base
+
+      - name: Build project for distribution
+        run: make build main=true args="--no-sources --wheel"
+      - name: Test CLI
+        run: |
+          uv pip install dist/*.whl
+          uv run python -m langflow run --host 127.0.0.1 --port 7860 --backend-only &
+          SERVER_PID=$!
+          # Wait for the server to start
+          timeout 120 bash -c 'until curl -f http://127.0.0.1:7860/health_check; do sleep 2; done' || (echo "Server did not start in time" && kill $SERVER_PID && exit 1)
+          # Terminate the server
+          kill $SERVER_PID || (echo "Failed to terminate the server" && exit 1)
+          sleep 20 # give the server some time to terminate
+          # Check if the server is still running
+          if kill -0 $SERVER_PID 2>/dev/null; then
+            echo "Failed to terminate the server"
+            exit 0
+          else
+            echo "Server terminated successfully"
+          fi
+      - name: Publish to PyPI
+        env:
+          POETRY_PYPI_TOKEN_PYPI: ${{ secrets.PYPI_API_TOKEN }}
+          UV_PUBLISH_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
+        run: |
+          make publish main=true
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist-main
+          path: dist
+
+  call_docker_build_base:
+    name: Call Docker Build Workflow for Langflow Base
+    if: always() && ${{ inputs.build_docker_base == 'true' }}
+    needs: [release-nightly-base, release-nightly-main]
+    uses: ./.github/workflows/docker-build.yml
+    with:
+      release_type: nightly-base
+      base_version: ${{ inputs.nightly_tag_base }}
+      main_version: ${{ inputs.nightly_tag_main }}
+    secrets: inherit
+
+  call_docker_build_main:
+    name: Call Docker Build Workflow for Langflow
+    if: always() && ${{ inputs.build_docker_main == 'true' }}
+    needs: [release-nightly-main]
+    uses: ./.github/workflows/docker-build.yml
+    with:
+      release_type: nightly-main
+      main_version: ${{ inputs.nightly_tag_main }}
+    secrets: inherit
+
+  call_docker_build_main_ep:
+    name: Call Docker Build Workflow for Langflow with Entrypoint
+    if: always() && ${{ inputs.build_docker_ep == 'true' }}
+    needs: [release-nightly-main]
+    uses: ./.github/workflows/docker-build.yml
+    with:
+      release_type: main-ep
+      main_version: ${{ inputs.nightly_tag_main }}
+    secrets: inherit

.github/workflows/store_pytest_durations.yml

@@ -0,0 +1,65 @@
+name: Store pytest durations
+
+on:
+  workflow_dispatch:
+  schedule:
+    # Run job at 6:30 UTC, 10.30pm PST, or 11.30pm PDT
+    - cron: "30 6 * * *"
+
+env:
+  PYTEST_RUN_PATH: "src/backend/tests"
+
+jobs:
+  build:
+    name: Run pytest and store durations
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+    env:
+      UV_CACHE_DIR: /tmp/.uv-cache
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+        with:
+          enable-cache: true
+          cache-dependency-glob: "uv.lock"
+      - name: "Set up Python"
+        uses: actions/setup-python@v5
+        with:
+          python-version-file: "pyproject.toml"
+      - name: Restore uv cache
+        uses: actions/cache@v4
+        with:
+          path: /tmp/.uv-cache
+          key: uv-${{ runner.os }}-${{ hashFiles('uv.lock') }}
+          restore-keys: |
+            uv-${{ runner.os }}-${{ hashFiles('uv.lock') }}
+            uv-${{ runner.os }}
+      - name: Install the project
+        run: uv sync --dev
+      - name: Run unit tests
+        uses: nick-fields/retry@v3
+        with:
+          timeout_minutes: 12
+          max_attempts: 2
+          command: uv run pytest src/backend/tests --durations-path src/backend/tests/.test_durations --splitting-algorithm least_duration --store-durations
+      - name: Minimize uv cache
+        run: uv cache prune --ci
+
+      - name: Create Pull Request
+        uses: peter-evans/create-pull-request@v7
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          branch-token: ${{ secrets.GITHUB_TOKEN }}
+          commit-message: "chore: update test durations"
+          title: "chore: update test durations"
+          body: |
+            Automated PR to update test durations file.
+
+            This PR was automatically created by the store_pytest_durations workflow.
+          branch: update-test-durations
+          branch-suffix: timestamp
+          delete-branch: true
+          maintainer-can-modify: true

.github/workflows/style-check-py.yml

@@ -0,0 +1,31 @@
+name: Ruff Style Check
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened, auto_merge_enabled]
+    paths:
+      - "**/*.py"
+
+
+
+
+
+jobs:
+  lint:
+    name: Ruff Style Check
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.12"
+    steps:
+      - name: Check out the code at a specific ref
+        uses: actions/checkout@v4
+      - name: "Setup Environment"
+        uses: ./.github/actions/setup-uv
+      - name: Register problem matcher
+        run: echo "::add-matcher::.github/workflows/matchers/ruff.json"
+      - name: Run Ruff Check
+        run: uv run --only-dev ruff check --output-format=github .
+      - name: Minimize uv cache
+        run: uv cache prune --ci

.github/workflows/typescript_test.yml

@@ -0,0 +1,348 @@
+name: Run Frontend Tests
+
+on:
+  workflow_call:
+    secrets:
+      OPENAI_API_KEY:
+        required: true
+      STORE_API_KEY:
+        required: true
+      ANTHROPIC_API_KEY:
+        required: true
+      TAVILY_API_KEY:
+        required: true
+    inputs:
+      suites:
+        description: "Test suites to run (JSON array)"
+        required: false
+        type: string
+        default: '[]'
+      release:
+        description: "Whether this is a release build"
+        required: false
+        type: boolean
+        default: false
+      tests_folder:
+        description: "(Optional) Tests to run"
+        required: false
+        type: string
+        default: "tests"
+      ref:
+        description: "(Optional) ref to checkout"
+        required: false
+        type: string
+  workflow_dispatch:
+    inputs:
+      suites:
+        description: "Test suites to run (JSON array)"
+        required: false
+        type: string
+        default: '[]'
+      release:
+        description: "Whether this is a release build"
+        required: false
+        type: boolean
+        default: false
+      tests_folder:
+        description: "(Optional) Tests to run"
+        required: false
+        type: string
+        default: "tests"
+
+env:
+  NODE_VERSION: "21"
+  PYTHON_VERSION: "3.12"
+  # Define the directory where Playwright browsers will be installed.
+  # Adjust if your project uses a different path.
+  PLAYWRIGHT_BROWSERS_PATH: "ms-playwright"
+
+jobs:
+  determine-test-suite:
+    name: Determine Test Suites and Shard Distribution
+    runs-on: ubuntu-latest
+    outputs:
+      matrix: ${{ steps.setup-matrix.outputs.matrix }}
+      test_grep: ${{ steps.set-matrix.outputs.test_grep }}
+      suites: ${{ steps.set-matrix.outputs.suites }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref || github.ref }}
+          fetch-depth: 0
+
+      - name: Paths Filter
+        id: filter
+        uses: dorny/paths-filter@v3
+        with:
+          filters: .github/changes-filter.yaml
+
+      - name: Determine Test Suites from Changes
+        id: set-matrix
+        run: |
+          # Start with input suites if provided, otherwise empty array
+          echo "Changes filter output: ${{ steps.filter.outputs }}"
+          SUITES='${{ inputs.suites }}'
+          echo "Initial suites: $SUITES"
+          TEST_GREP=""
+
+          RELEASE="${{ inputs.release || 'false' }}"
+          echo "Release build: $RELEASE"
+
+          # Only set to release if it's explicitly a release build
+          if [[ "$RELEASE" == "true" ]]; then
+            SUITES='["release"]'
+            echo "Release build detected - setting suites to: $SUITES"
+            # grep pattern for release is the @release tag - run all tests
+            TEST_GREP="--grep=\"@release\""
+          else
+            # If input suites were not provided, determine based on changes
+            if [[ "$SUITES" == "[]" ]]; then
+              echo "No input suites provided - determining from changes"
+              TAGS=()
+              # Add suites and tags based on changed files
+              if [[ "${{ steps.filter.outputs.components }}" == "true" ]]; then
+                SUITES=$(echo $SUITES | jq -c '. += ["components"]')
+                TAGS+=("@components")
+                echo "Added components suite"
+              fi
+              if [[ "${{ steps.filter.outputs.starter-projects }}" == "true" ]]; then
+                SUITES=$(echo $SUITES | jq -c '. += ["starter-projects"]')
+                TAGS+=("@starter-projects")
+                echo "Added starter-projects suite"
+              fi
+              if [[ "${{ steps.filter.outputs.workspace }}" == "true" ]]; then
+                SUITES=$(echo $SUITES | jq -c '. += ["workspace"]')
+                TAGS+=("@workspace")
+                echo "Added workspace suite"
+              fi
+              if [[ "${{ steps.filter.outputs.api }}" == "true" ]]; then
+                SUITES=$(echo $SUITES | jq -c '. += ["api"]')
+                TAGS+=("@api")
+                echo "Added api suite"
+              fi
+              if [[ "${{ steps.filter.outputs.database }}" == "true" ]]; then
+                SUITES=$(echo $SUITES | jq -c '. += ["database"]')
+                TAGS+=("@database")
+                echo "Added database suite"
+              fi
+
+              # Create grep pattern if we have tags
+              if [ ${#TAGS[@]} -gt 0 ]; then
+                # Join tags with | for OR logic
+                REGEX_PATTERN=$(IFS='|'; echo "${TAGS[*]}")
+                TEST_GREP="--grep=\"${REGEX_PATTERN}\""
+              fi
+            else
+              # Process input suites to tags
+              TAGS=()
+              if echo "$SUITES" | jq -e 'contains(["components"])' > /dev/null; then
+                TAGS+=("@components")
+              fi
+              if echo "$SUITES" | jq -e 'contains(["starter-projects"])' > /dev/null; then
+                TAGS+=("@starter-projects")
+              fi
+              if echo "$SUITES" | jq -e 'contains(["workspace"])' > /dev/null; then
+                TAGS+=("@workspace")
+              fi
+              if echo "$SUITES" | jq -e 'contains(["api"])' > /dev/null; then
+                TAGS+=("@api")
+              fi
+              if echo "$SUITES" | jq -e 'contains(["database"])' > /dev/null; then
+                TAGS+=("@database")
+              fi
+
+              if [ ${#TAGS[@]} -gt 0 ]; then
+                # Join tags with | for OR logic
+                REGEX_PATTERN=$(IFS='|'; echo "${TAGS[*]}")
+                TEST_GREP="--grep \"${REGEX_PATTERN}\""
+              fi
+            fi
+          fi
+
+          # Ensure compact JSON output
+          SUITES=$(echo "$SUITES" | jq -c '.')
+
+          echo "Final test suites to run: $SUITES"
+          echo "Test grep pattern: $TEST_GREP"
+          # Ensure proper JSON formatting for matrix output
+          echo "matrix=$(echo $SUITES | jq -c .)" >> $GITHUB_OUTPUT
+          echo "test_grep=$TEST_GREP" >> $GITHUB_OUTPUT
+
+      - name: Setup Node ${{ env.NODE_VERSION }}
+        uses: actions/setup-node@v4
+        id: setup-node
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+          cache: "npm"
+          cache-dependency-path: ./src/frontend/package-lock.json
+
+      - name: Install Frontend Dependencies
+        run: npm ci
+        working-directory: ./src/frontend
+
+      - name: Calculate Test Shards Distribution
+        id: setup-matrix
+        run: |
+          cd src/frontend
+
+          # Get the test count using playwright's built-in grep
+          if [ -n "${{ steps.set-matrix.outputs.test_grep }}" ]; then
+            TEST_COUNT=$(npx playwright test ${{ inputs.tests_folder }} ${{ steps.set-matrix.outputs.test_grep }} --list | wc -l)
+          else
+            TEST_COUNT=$(npx playwright test ${{ inputs.tests_folder }} --list | wc -l)
+          fi
+
+          echo "Total tests to run: $TEST_COUNT"
+
+          # Calculate optimal shard count - 1 shard per 5 tests, min 1, max 10
+          SHARD_COUNT=$(( (TEST_COUNT + 4) / 5 ))
+          if [ $SHARD_COUNT -lt 1 ]; then
+            SHARD_COUNT=1
+          elif [ $SHARD_COUNT -gt 10 ]; then
+            SHARD_COUNT=10
+          fi
+
+          # Create the matrix combinations string
+          MATRIX_COMBINATIONS=""
+          for i in $(seq 1 $SHARD_COUNT); do
+            if [ $i -gt 1 ]; then
+              MATRIX_COMBINATIONS="$MATRIX_COMBINATIONS,"
+            fi
+            MATRIX_COMBINATIONS="$MATRIX_COMBINATIONS{\"shardIndex\": $i, \"shardTotal\": $SHARD_COUNT}"
+          done
+
+          echo "matrix={\"include\":[$MATRIX_COMBINATIONS]}" >> "$GITHUB_OUTPUT"
+
+  setup-and-test:
+    name: Playwright Tests - Shard ${{ matrix.shardIndex }}/${{ matrix.shardTotal }}
+    runs-on: ubuntu-latest
+    if: ${{ needs.determine-test-suite.outputs.test_grep != '' }}
+    needs: determine-test-suite
+    strategy:
+      fail-fast: false
+      matrix: ${{ fromJson(needs.determine-test-suite.outputs.matrix) }}
+    env:
+      OPENAI_API_KEY: ${{ inputs.openai_api_key || secrets.OPENAI_API_KEY }}
+      STORE_API_KEY: ${{ inputs.store_api_key || secrets.STORE_API_KEY }}
+      SEARCH_API_KEY: "${{ secrets.SEARCH_API_KEY }}"
+      ASTRA_DB_APPLICATION_TOKEN: "${{ secrets.ASTRA_DB_APPLICATION_TOKEN }}"
+      ASTRA_DB_API_ENDPOINT: "${{ secrets.ASTRA_DB_API_ENDPOINT }}"
+      ANTHROPIC_API_KEY: "${{ secrets.ANTHROPIC_API_KEY }}"
+      TAVILY_API_KEY: "${{ secrets.TAVILY_API_KEY }}"
+      UV_CACHE_DIR: /tmp/.uv-cache
+    outputs:
+      failed: ${{ steps.check-failure.outputs.failed }}
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.ref || github.ref }}
+
+      - name: Setup Node.js Environment
+        uses: actions/setup-node@v4
+        id: setup-node
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+          cache: "npm"
+          cache-dependency-path: ./src/frontend/package-lock.json
+
+      - name: Install Frontend Dependencies
+        run: npm ci
+        working-directory: ./src/frontend
+
+      - name: Install Playwright Browser Dependencies
+        id: install-playwright
+        uses: ./.github/actions/install-playwright
+        with:
+          working-directory: ./src/frontend
+          browsers: chromium
+
+      - name: Setup Python Environment with UV
+        uses: ./.github/actions/setup-uv
+
+      - name: Install Python Dependencies
+        run: uv sync --dev
+
+      - name: Configure Environment Variables
+        run: |
+          touch .env
+          echo "${{ secrets.ENV_VARS }}" > .env
+
+      - name: Execute Playwright Tests
+        uses: nick-fields/retry@v3
+        with:
+          timeout_minutes: 12
+          max_attempts: 2
+          command: |
+            cd src/frontend
+            echo 'Running tests with pattern: ${{ needs.determine-test-suite.outputs.test_grep }}'
+            npx playwright test ${{ inputs.tests_folder }} ${{ needs.determine-test-suite.outputs.test_grep }} --shard ${{ matrix.shardIndex }}/${{ matrix.shardTotal }} --list
+            # echo command before running
+            echo "npx playwright test ${{ inputs.tests_folder }} ${{ needs.determine-test-suite.outputs.test_grep }} --trace on --shard ${{ matrix.shardIndex }}/${{ matrix.shardTotal }} --workers 2"
+
+            npx playwright test ${{ inputs.tests_folder }} ${{ needs.determine-test-suite.outputs.test_grep }} --trace on --shard ${{ matrix.shardIndex }}/${{ matrix.shardTotal }} --workers 2
+
+      - name: Upload Test Results
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: blob-report-${{ matrix.shardIndex }}
+          path: src/frontend/blob-report
+          retention-days: 1
+
+      - name: Cleanup UV Cache
+        run: uv cache prune --ci
+
+  merge-reports:
+    # We need to repeat the condition at every step
+    # https://github.com/actions/runner/issues/662
+    needs: setup-and-test
+    runs-on: ubuntu-latest
+    if: always()
+    env:
+      EXIT_CODE: ${{!contains(needs.setup-and-test.result, 'failure') && !contains(needs.setup-and-test.result, 'cancelled') && '0' || '1'}}
+    steps:
+      - name: "Should Merge Reports"
+        # If the CI was successful, we don't need to merge the reports
+        # so we can skip all the steps below
+        id: should_merge_reports
+        run: |
+          if [ "$EXIT_CODE" == "0" ]; then
+            echo "should_merge_reports=false" >> $GITHUB_OUTPUT
+          else
+            echo "should_merge_reports=true" >> $GITHUB_OUTPUT
+          fi
+      - name: Checkout code
+        if: ${{ steps.should_merge_reports.outputs.should_merge_reports == 'true' }}
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+
+        if: ${{ steps.should_merge_reports.outputs.should_merge_reports == 'true' }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ env.NODE_VERSION }}
+
+      - name: Download blob reports from GitHub Actions Artifacts
+
+        if: ${{ steps.should_merge_reports.outputs.should_merge_reports == 'true' }}
+        uses: actions/download-artifact@v4
+        with:
+          path: all-blob-reports
+          pattern: blob-report-*
+          merge-multiple: true
+
+      - name: Merge into HTML Report
+
+        if: ${{ steps.should_merge_reports.outputs.should_merge_reports == 'true' }}
+        run: |
+          npx playwright merge-reports --reporter html ./all-blob-reports
+
+      - name: Upload HTML report
+
+        if: ${{ steps.should_merge_reports.outputs.should_merge_reports == 'true' }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: html-report--attempt-${{ github.run_attempt }}
+          path: playwright-report
+          retention-days: 14

.gitignore

@@ -0,0 +1,279 @@
+# This is to avoid Opencommit hook from getting pushed
+prepare-commit-msg
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+qdrant_storage
+
+.dspy_cache
+# Mac
+.DS_Store
+
+# VSCode
+.vscode/settings.json
+.chroma
+.ruff_cache
+
+# PyCharm
+.idea/
+
+# Diagnostic reports (https://nodejs.org/api/report.html)
+report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+*.lcov
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# Bower dependency directory (https://bower.io/)
+bower_components
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (https://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules/
+jspm_packages/
+
+# TypeScript v1 declaration files
+typings/
+
+# TypeScript cache
+*.tsbuildinfo
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Microbundle cache
+.rpt2_cache/
+.rts2_cache_cjs/
+.rts2_cache_es/
+.rts2_cache_umd/
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+# dotenv environment variables file
+.env
+.env.test
+
+# parcel-bundler cache (https://parceljs.org/)
+.cache
+
+# Next.js build output
+.next
+
+# Nuxt.js build / generate output
+.nuxt
+dist
+
+# Gatsby files
+.cache/
+# Comment in the public line in if your project uses Gatsby and *not* Next.js
+# https://nextjs.org/blog/next-9-1#public-directory-support
+# public
+
+# vuepress build output
+.vuepress/dist
+
+# Serverless directories
+.serverless/
+
+# FuseBox cache
+.fusebox/
+
+# DynamoDB Local files
+.dynamodb/
+
+# TernJS port file
+.tern-port
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+notebooks
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+.testmondata*
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+*.db-shm
+*.db-wal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Poetry
+.testenv/*
+langflow.db
+
+
+.githooks/prepare-commit-msg
+.langchain.db
+
+# docusaurus
+.docusaurus/
+
+/tmp/*
+src/backend/langflow/frontend/
+src/backend/base/langflow/frontend/
+.docker
+scratchpad*
+chroma*/*
+stuff/*
+src/frontend/playwright-report/index.html
+*.bak
+prof/*
+
+src/frontend/temp
+*-shm
+*-wal
+.history
+
+.dspy_cache/
+*.db

.pre-commit-config.yaml

@@ -0,0 +1,25 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.1.0
+    hooks:
+      - id: check-case-conflict
+      - id: end-of-file-fixer
+        # python, js and ts only
+        files: \.(py|js|ts)$
+      - id: mixed-line-ending
+        files: \.(py|js|ts)$
+        args:
+          - --fix=lf
+      - id: trailing-whitespace
+  - repo: local
+    hooks:
+      - id: ruff-check
+        name: ruff check
+        language: system
+        entry: bash -c "uv run ruff check"
+        types: [file, python]
+      - id: ruff-format
+        name: ruff format
+        language: system
+        entry: bash -c "uv run ruff format"
+        types: [file, python]

.vscode/launch.json

@@ -0,0 +1,80 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Debug Backend",
+      "type": "debugpy",
+      "request": "launch",
+      "module": "uvicorn",
+      "preLaunchTask": "Install Backend",
+
+      "args": [
+        "--factory",
+        "langflow.main:create_app",
+        "--port",
+        "7860",
+        "--reload",
+        "--log-level",
+        "debug",
+        "--loop",
+        "asyncio",
+        "--reload-include",
+        "./src/backend/*"
+      ],
+      "jinja": true,
+      "justMyCode": false,
+      "env": {
+        "LANGFLOW_LOG_LEVEL": "debug",
+        "LANGFLOW_PROMETHEUS_PORT": "9090"
+      },
+      "envFile": "${workspaceFolder}/.env"
+    },
+    {
+      "name": "Debug CLI",
+      "type": "debugpy",
+      "request": "launch",
+      "module": "langflow",
+      "args": [
+        "run",
+        "--path",
+        "${workspaceFolder}/src/backend/base/langflow/frontend",
+        "--env-file",
+        "${workspaceFolder}/.env"
+      ],
+      // "python": "/path/to/your/python_env/python", // Replace with the path to your Python executable
+      "jinja": true,
+      "justMyCode": false
+    },
+    {
+      "name": "Python: Remote Attach",
+      "type": "debugpy",
+      "request": "attach",
+      "justMyCode": true,
+      "connect": {
+        "port": 5678
+      },
+      "pathMappings": [
+        {
+          "localRoot": "${workspaceFolder}",
+          "remoteRoot": "."
+        }
+      ]
+    },
+    {
+      "name": "Debug Frontend",
+      "type": "chrome",
+      "request": "launch",
+      "url": "http://localhost:3000/",
+      "webRoot": "${workspaceRoot}/src/frontend"
+    },
+    {
+      "name": "Python: Debug Tests",
+      "type": "debugpy",
+      "request": "launch",
+      "program": "${file}",
+      "purpose": ["debug-test"],
+      "console": "integratedTerminal",
+      "justMyCode": false
+    }
+  ]
+}

.vscode/tasks.json

@@ -0,0 +1,54 @@
+{
+  // See https://go.microsoft.com/fwlink/?LinkId=733558
+  // for the documentation about the tasks.json format
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "Init",
+      "type": "shell",
+      "command": "make init"
+    },
+    // make backend
+    {
+      "label": "Backend",
+      "type": "shell",
+      "command": "make backend"
+    },
+    // make frontend
+    {
+      "label": "Frontend",
+      "type": "shell",
+      "command": "make frontend"
+    },
+    // make test
+    {
+      "label": "Test",
+      "type": "shell",
+      "command": "make unit_tests"
+    },
+    // make lint
+    {
+      "label": "Lint",
+      "type": "shell",
+      "command": "make lint"
+    },
+    // make format
+    {
+      "label": "Format",
+      "type": "shell",
+      "command": "make format"
+    },
+    // make install
+    {
+      "label": "Install",
+      "type": "shell",
+      "command": "make install_backend && make install_frontend"
+    },
+    // install backend
+    {
+      "label": "Install Backend",
+      "type": "shell",
+      "command": "make install_backend"
+    }
+  ]
+}

CODE_OF_CONDUCT.md

@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socioeconomic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+- Demonstrating empathy and kindness toward other people
+- Being respectful of differing opinions, viewpoints, and experiences
+- Giving and gracefully accepting constructive feedback
+- Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+- Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+- The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+- Trolling, insulting or derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+- Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+contact@langflow.org.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

CONTRIBUTING.md

@@ -0,0 +1,102 @@
+# Contributing to Langflow
+
+This guide is intended to help you get started contributing to Langflow.
+As an open-source project in a rapidly developing field, we are extremely open
+to contributions, whether it be in the form of a new feature, improved infra, or better documentation.
+
+To contribute to this project, please follow the [fork and pull request](https://docs.github.com/en/get-started/quickstart/contributing-to-projects) workflow.
+
+## Reporting bugs or suggesting improvements
+
+Our [GitHub issues](https://github.com/langflow-ai/langflow/issues) page is kept up to date
+with bugs, improvements, and feature requests. There is a taxonomy of labels to help
+with sorting and discovery of issues of interest. [See this page](https://github.com/langflow-ai/langflow/labels) for an overview of
+the system we use to tag our issues and pull requests.
+
+If you're looking for help with your code, consider posting a question on the
+[GitHub Discussions board](https://github.com/langflow-ai/langflow/discussions). Please
+understand that we won't be able to provide individual support via email. We
+also believe that help is much more valuable if it's **shared publicly**,
+so that more people can benefit from it.
+
+- **Describing your issue:** Try to provide as many details as possible. What
+  exactly goes wrong? _How_ is it failing? Is there an error?
+  "XY doesn't work" usually isn't that helpful for tracking down problems. Always
+  remember to include the code you ran and if possible, extract only the relevant
+  parts and don't just dump your entire script. This will make it easier for us to
+  reproduce the error.
+
+- **Sharing long blocks of code or logs:** If you need to include long code,
+  logs or tracebacks, you can wrap them in `<details>` and `</details>`. This
+  [collapses the content](https://developer.mozilla.org/en/docs/Web/HTML/Element/details)
+  so it only becomes visible on click, making the issue easier to read and follow.
+
+## Contributing code and documentation
+
+You can develop Langflow locally via uv + NodeJS.
+
+### Clone the Langflow Repository
+
+Navigate to the [Langflow GitHub repository](https://github.com/langflow-ai/langflow) and press "Fork" in the upper right-hand corner.
+
+Add the new remote to your local repository on your local machine:
+
+```bash
+git remote add fork https://github.com/<your username>/langflow.git
+```
+
+We also provide a .vscode/launch.json file for debugging the backend in VSCode, which is a lot faster than using docker compose.
+
+### Prepare the environment
+
+Setting up hooks:
+
+```bash
+make init
+```
+
+This will set up the development environment by installing backend and frontend dependencies, building the frontend static files, and initializing the project. It runs `make install_backend`, `make install_frontend`, `make build_frontend`, and finally `uv run langflow run` to start the application.
+
+It is advised to run `make lint`, `make format`, and `make unit_tests` before pushing to the repository.
+
+### Run locally (uv and Node.js)
+
+Langflow can run locally by cloning the repository and installing the dependencies. We recommend using a virtual environment to isolate the dependencies from your system.
+
+Before you start, make sure you have the following installed:
+
+- uv (>=0.4)
+- Node.js
+
+Then, in the root folder, install the dependencies and start the development server for the backend:
+
+```bash
+make backend
+```
+
+And the frontend:
+
+```bash
+make frontend
+```
+
+### Run documentation
+
+The documentation is built using [Docusaurus](https://docusaurus.io/). To run the documentation locally, run the following commands:
+
+```bash
+cd docs
+npm install
+npm run start
+```
+
+The documentation will be available at `localhost:3000` and all the files are located in the `docs/docs` folder.
+
+## Opening a pull request
+
+Once you wrote and manually tested your change, you can start sending the patch to the main repository.
+
+- Open a new GitHub pull request with the patch against the `main` branch.
+- Ensure the PR title follows semantic commits conventions.
+  - For example, `feat: add new feature`, `fix: correct issue with X`.
+- Ensure the PR description clearly describes the problem and solution. Include the relevant issue number if applicable.

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Langflow
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Makefile

@@ -0,0 +1,446 @@
+.PHONY: all init format lint build build_frontend install_frontend run_frontend run_backend dev help tests coverage clean_python_cache clean_npm_cache clean_all
+
+# Configurations
+VERSION=$(shell grep "^version" pyproject.toml | sed 's/.*\"\(.*\)\"$$/\1/')
+DOCKERFILE=docker/build_and_push.Dockerfile
+DOCKERFILE_BACKEND=docker/build_and_push_backend.Dockerfile
+DOCKERFILE_FRONTEND=docker/frontend/build_and_push_frontend.Dockerfile
+DOCKER_COMPOSE=docker_example/docker-compose.yml
+PYTHON_REQUIRED=$(shell grep '^requires-python[[:space:]]*=' pyproject.toml | sed -n 's/.*"\([^"]*\)".*/\1/p')
+RED=\033[0;31m
+NC=\033[0m # No Color
+GREEN=\033[0;32m
+
+log_level ?= debug
+host ?= 0.0.0.0
+port ?= 7860
+env ?= .env
+open_browser ?= true
+path = src/backend/base/langflow/frontend
+workers ?= 1
+async ?= true
+lf ?= false
+ff ?= true
+all: help
+
+######################
+# UTILITIES
+######################
+
+# increment the patch version of the current package
+patch: ## bump the version in langflow and langflow-base
+	@echo 'Patching the version'
+	@poetry version patch
+	@echo 'Patching the version in langflow-base'
+	@cd src/backend/base && poetry version patch
+	@make lock
+
+# check for required tools
+check_tools:
+	@command -v uv >/dev/null 2>&1 || { echo >&2 "$(RED)uv is not installed. Aborting.$(NC)"; exit 1; }
+	@command -v npm >/dev/null 2>&1 || { echo >&2 "$(RED)NPM is not installed. Aborting.$(NC)"; exit 1; }
+	@echo "$(GREEN)All required tools are installed.$(NC)"
+
+
+help: ## show this help message
+	@echo '----'
+	@grep -hE '^\S+:.*##' $(MAKEFILE_LIST) | \
+	awk -F ':.*##' '{printf "\033[36mmake %s\033[0m: %s\n", $$1, $$2}' | \
+	column -c2 -t -s :
+	@echo '----'
+
+######################
+# INSTALL PROJECT
+######################
+
+reinstall_backend: ## forces reinstall all dependencies (no caching)
+	@echo 'Installing backend dependencies'
+	@uv sync -n --reinstall --frozen
+
+install_backend: ## install the backend dependencies
+	@echo 'Installing backend dependencies'
+	@uv sync --frozen
+
+install_frontend: ## install the frontend dependencies
+	@echo 'Installing frontend dependencies'
+	@cd src/frontend && npm install > /dev/null 2>&1
+
+build_frontend: ## build the frontend static files
+	@echo 'Building frontend static files'
+	@cd src/frontend && CI='' npm run build > /dev/null 2>&1
+	@rm -rf src/backend/base/langflow/frontend
+	@cp -r src/frontend/build src/backend/base/langflow/frontend
+
+init: check_tools clean_python_cache clean_npm_cache ## initialize the project
+	@make install_backend
+	@make install_frontend
+	@make build_frontend
+	@echo "$(GREEN)All requirements are installed.$(NC)"
+	@uv run langflow run
+
+######################
+# CLEAN PROJECT
+######################
+
+clean_python_cache:
+	@echo "Cleaning Python cache..."
+	find . -type d -name '__pycache__' -exec rm -r {} +
+	find . -type f -name '*.py[cod]' -exec rm -f {} +
+	find . -type f -name '*~' -exec rm -f {} +
+	find . -type f -name '.*~' -exec rm -f {} +
+	find . -type d -empty -delete
+	@echo "$(GREEN)Python cache cleaned.$(NC)"
+
+clean_npm_cache:
+	@echo "Cleaning npm cache..."
+	cd src/frontend && npm cache clean --force
+	rm -rf src/frontend/node_modules src/frontend/build src/backend/base/langflow/frontend src/frontend/package-lock.json
+	@echo "$(GREEN)NPM cache and frontend directories cleaned.$(NC)"
+
+clean_all: clean_python_cache clean_npm_cache # clean all caches and temporary directories
+	@echo "$(GREEN)All caches and temporary directories cleaned.$(NC)"
+
+setup_uv: ## install poetry using pipx
+	pipx install uv
+
+add:
+	@echo 'Adding dependencies'
+ifdef devel
+	@cd src/backend/base && uv add --group dev $(devel)
+endif
+
+ifdef main
+	@uv add $(main)
+endif
+
+ifdef base
+	@cd src/backend/base && uv add $(base)
+endif
+
+
+
+######################
+# CODE TESTS
+######################
+
+coverage: ## run the tests and generate a coverage report
+	@uv run coverage run
+	@uv run coverage erase
+
+unit_tests: ## run unit tests
+	@uv sync --extra dev --frozen
+	@EXTRA_ARGS=""
+	@if [ "$(async)" = "true" ]; then \
+		EXTRA_ARGS="$$EXTRA_ARGS --instafail -n auto"; \
+	fi; \
+	if [ "$(lf)" = "true" ]; then \
+		EXTRA_ARGS="$$EXTRA_ARGS --lf"; \
+	fi; \
+	if [ "$(ff)" = "true" ]; then \
+		EXTRA_ARGS="$$EXTRA_ARGS --ff"; \
+	fi; \
+	uv run pytest src/backend/tests --ignore=src/backend/tests/integration $$EXTRA_ARGS --instafail -ra -m 'not api_key_required' --durations-path src/backend/tests/.test_durations --splitting-algorithm least_duration $(args)
+
+unit_tests_looponfail:
+	@make unit_tests args="-f"
+
+integration_tests:
+	uv run pytest src/backend/tests/integration \
+		--instafail -ra \
+		$(args)
+
+integration_tests_no_api_keys:
+	uv run pytest src/backend/tests/integration \
+		--instafail -ra -m "not api_key_required" \
+		$(args)
+
+integration_tests_api_keys:
+	uv run pytest src/backend/tests/integration \
+		--instafail -ra -m "api_key_required" \
+		$(args)
+
+tests: ## run unit, integration, coverage tests
+	@echo 'Running Unit Tests...'
+	make unit_tests
+	@echo 'Running Integration Tests...'
+	make integration_tests
+	@echo 'Running Coverage Tests...'
+	make coverage
+
+######################
+# CODE QUALITY
+######################
+
+codespell: ## run codespell to check spelling
+	@poetry install --with spelling
+	poetry run codespell --toml pyproject.toml
+
+fix_codespell: ## run codespell to fix spelling errors
+	@poetry install --with spelling
+	poetry run codespell --toml pyproject.toml --write
+
+format: ## run code formatters
+	@uv run ruff check . --fix
+	@uv run ruff format . --config pyproject.toml
+	@cd src/frontend && npm run format
+
+unsafe_fix:
+	@uv run ruff check . --fix --unsafe-fixes
+
+lint: install_backend ## run linters
+	@uv run mypy --namespace-packages -p "langflow"
+
+install_frontendci:
+	@cd src/frontend && npm ci > /dev/null 2>&1
+
+install_frontendc:
+	@cd src/frontend && rm -rf node_modules package-lock.json && npm install > /dev/null 2>&1
+
+run_frontend: ## run the frontend
+	@-kill -9 `lsof -t -i:3000`
+	@cd src/frontend && npm start
+
+tests_frontend: ## run frontend tests
+ifeq ($(UI), true)
+	@cd src/frontend && npx playwright test --ui --project=chromium
+else
+	@cd src/frontend && npx playwright test --project=chromium
+endif
+
+run_cli: install_frontend install_backend build_frontend ## run the CLI
+	@echo 'Running the CLI'
+	@uv run langflow run \
+		--frontend-path $(path) \
+		--log-level $(log_level) \
+		--host $(host) \
+		--port $(port) \
+		$(if $(env),--env-file $(env),) \
+		$(if $(filter false,$(open_browser)),--no-open-browser)
+
+run_cli_debug:
+	@echo 'Running the CLI in debug mode'
+	@make install_frontend > /dev/null
+	@echo 'Building the frontend'
+	@make build_frontend > /dev/null
+	@echo 'Install backend dependencies'
+	@make install_backend > /dev/null
+ifdef env
+	@make start env=$(env) host=$(host) port=$(port) log_level=debug
+else
+	@make start host=$(host) port=$(port) log_level=debug
+endif
+
+
+setup_devcontainer: ## set up the development container
+	make install_backend
+	make install_frontend
+	make build_frontend
+	uv run langflow --frontend-path src/frontend/build
+
+setup_env: ## set up the environment
+	@sh ./scripts/setup/setup_env.sh
+
+frontend: install_frontend ## run the frontend in development mode
+	make run_frontend
+
+frontendc: install_frontendc
+	make run_frontend
+
+
+backend: setup_env install_backend ## run the backend in development mode
+	@-kill -9 $$(lsof -t -i:7860) || true
+ifdef login
+	@echo "Running backend autologin is $(login)";
+	LANGFLOW_AUTO_LOGIN=$(login) uv run uvicorn \
+		--factory langflow.main:create_app \
+		--host 0.0.0.0 \
+		--port $(port) \
+		$(if $(filter-out 1,$(workers)),, --reload) \
+		--env-file $(env) \
+		--loop asyncio \
+		$(if $(workers),--workers $(workers),)
+else
+	@echo "Running backend respecting the $(env) file";
+	uv run uvicorn \
+		--factory langflow.main:create_app \
+		--host 0.0.0.0 \
+		--port $(port) \
+		$(if $(filter-out 1,$(workers)),, --reload) \
+		--env-file $(env) \
+		--loop asyncio \
+		$(if $(workers),--workers $(workers),)
+endif
+
+build_and_run: setup_env ## build the project and run it
+	rm -rf dist
+	rm -rf src/backend/base/dist
+	make build
+	uv run pip install dist/*.tar.gz
+	uv run langflow run
+
+build_and_install: ## build the project and install it
+	@echo 'Removing dist folder'
+	rm -rf dist
+	rm -rf src/backend/base/dist
+	make build && uv run pip install dist/*.whl && pip install src/backend/base/dist/*.whl --force-reinstall
+
+build: setup_env ## build the frontend static files and package the project
+ifdef base
+	make install_frontendci
+	make build_frontend
+	make build_langflow_base args="$(args)"
+endif
+
+ifdef main
+	make install_frontendci
+	make build_frontend
+	make build_langflow_base args="$(args)"
+	make build_langflow args="$(args)"
+endif
+
+build_langflow_base:
+	cd src/backend/base && uv build $(args)
+	rm -rf src/backend/base/langflow/frontend
+
+build_langflow_backup:
+	uv lock && uv build
+
+build_langflow:
+	uv lock --no-upgrade
+	uv build $(args)
+ifdef restore
+	mv pyproject.toml.bak pyproject.toml
+	mv uv.lock.bak uv.lock
+endif
+
+
+docker_build: dockerfile_build clear_dockerimage ## build DockerFile
+
+docker_build_backend: dockerfile_build_be clear_dockerimage ## build Backend DockerFile
+
+docker_build_frontend: dockerfile_build_fe clear_dockerimage ## build Frontend Dockerfile
+
+dockerfile_build:
+	@echo 'BUILDING DOCKER IMAGE: ${DOCKERFILE}'
+	@docker build --rm \
+		-f ${DOCKERFILE} \
+		-t langflow:${VERSION} .
+
+dockerfile_build_be: dockerfile_build
+	@echo 'BUILDING DOCKER IMAGE BACKEND: ${DOCKERFILE_BACKEND}'
+	@docker build --rm \
+		--build-arg LANGFLOW_IMAGE=langflow:${VERSION} \
+		-f ${DOCKERFILE_BACKEND} \
+		-t langflow_backend:${VERSION} .
+
+dockerfile_build_fe: dockerfile_build
+	@echo 'BUILDING DOCKER IMAGE FRONTEND: ${DOCKERFILE_FRONTEND}'
+	@docker build --rm \
+		--build-arg LANGFLOW_IMAGE=langflow:${VERSION} \
+		-f ${DOCKERFILE_FRONTEND} \
+		-t langflow_frontend:${VERSION} .
+
+clear_dockerimage:
+	@echo 'Clearing the docker build'
+	@if docker images -f "dangling=true" -q | grep -q '.*'; then \
+		docker rmi $$(docker images -f "dangling=true" -q); \
+	fi
+
+docker_compose_up: docker_build docker_compose_down
+	@echo 'Running docker compose up'
+	docker compose -f $(DOCKER_COMPOSE) up --remove-orphans
+
+docker_compose_down:
+	@echo 'Running docker compose down'
+	docker compose -f $(DOCKER_COMPOSE) down || true
+
+dcdev_up:
+	@echo 'Running docker compose up'
+	docker compose -f docker/dev.docker-compose.yml down || true
+	docker compose -f docker/dev.docker-compose.yml up --remove-orphans
+
+lock_base:
+	cd src/backend/base && uv lock
+
+lock_langflow:
+	uv lock
+
+lock: ## lock dependencies
+	@echo 'Locking dependencies'
+	cd src/backend/base && uv lock
+	uv lock
+
+update: ## update dependencies
+	@echo 'Updating dependencies'
+	cd src/backend/base && uv sync --upgrade
+	uv sync --upgrade
+
+publish_base:
+	cd src/backend/base && uv publish
+
+publish_langflow:
+	uv publish
+
+publish_base_testpypi:
+	# TODO: update this to use the test-pypi repository
+	cd src/backend/base && uv publish -r test-pypi
+
+publish_langflow_testpypi:
+	# TODO: update this to use the test-pypi repository
+	uv publish -r test-pypi
+
+publish: ## build the frontend static files and package the project and publish it to PyPI
+	@echo 'Publishing the project'
+ifdef base
+	make publish_base
+endif
+
+ifdef main
+	make publish_langflow
+endif
+
+publish_testpypi: ## build the frontend static files and package the project and publish it to PyPI
+	@echo 'Publishing the project'
+
+ifdef base
+	#TODO: replace with uvx twine upload dist/*
+	poetry config repositories.test-pypi https://test.pypi.org/legacy/
+	make publish_base_testpypi
+endif
+
+ifdef main
+	#TODO: replace with uvx twine upload dist/*
+	poetry config repositories.test-pypi https://test.pypi.org/legacy/
+	make publish_langflow_testpypi
+endif
+
+
+# example make alembic-revision message="Add user table"
+alembic-revision: ## generate a new migration
+	@echo 'Generating a new Alembic revision'
+	cd src/backend/base/langflow/ && uv run alembic revision --autogenerate -m "$(message)"
+
+
+alembic-upgrade: ## upgrade database to the latest version
+	@echo 'Upgrading database to the latest version'
+	cd src/backend/base/langflow/ && uv run alembic upgrade head
+
+alembic-downgrade: ## downgrade database by one version
+	@echo 'Downgrading database by one version'
+	cd src/backend/base/langflow/ && uv run alembic downgrade -1
+
+alembic-current: ## show current revision
+	@echo 'Showing current Alembic revision'
+	cd src/backend/base/langflow/ && uv run alembic current
+
+alembic-history: ## show migration history
+	@echo 'Showing Alembic migration history'
+	cd src/backend/base/langflow/ && uv run alembic history --verbose
+
+alembic-check: ## check migration status
+	@echo 'Running alembic check'
+	cd src/backend/base/langflow/ && uv run alembic check
+
+alembic-stamp: ## stamp the database with a specific revision
+	@echo 'Stamping the database with revision $(revision)'
+	cd src/backend/base/langflow/ && uv run alembic stamp $(revision)

README.md

@@ -1,11 +0,0 @@
----
-title: Agent Flow
-emoji: 🐠
-colorFrom: indigo
-colorTo: purple
-sdk: static
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference