Release Langflow 1.0 (#2303)

This PR releases Langflow 1.0 in the main branch and updates the
documentation.

.devcontainer/devcontainer.json

@@ -3,7 +3,7 @@
 {
   "name": "Langflow Dev Container",
   // Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
-  "image": "mcr.microsoft.com/devcontainers/python:1-3.10-bullseye",
+  "image": "mcr.microsoft.com/devcontainers/python:3.10",
 
   // Features to add to the dev container. More info: https://containers.dev/features.
   "features": {

.dockerignore

@@ -1,7 +0,0 @@
-.venv/
-**/aws
-# node_modules
-**/node_modules/
-dist/
-**/build/
-src/backend/langflow/frontend

.env.example

@@ -4,6 +4,19 @@
 #        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:
@@ -56,6 +69,12 @@ LANGFLOW_REMOVE_API_KEYS=
 # 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=
@@ -64,6 +83,10 @@ LANGFLOW_SUPERUSER=
 # 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=
@@ -74,4 +97,8 @@ LANGFLOW_SUPERUSER_PASSWORD=
 
 # LIKE_WEBHOOK_URL
 #
-# LANGFLOW_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

@@ -32,3 +32,4 @@ Dockerfile text
 *.mp4 binary
 *.svg binary
 *.csv binary
+

.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/workflows/ci.yml

@@ -1,44 +0,0 @@
-name: "Async API tests"
-
-on:
-  push:
-    branches:
-      - dev
-  pull_request:
-    branches:
-      - dev
-      - main
-
-jobs:
-  build-and-test:
-    runs-on: ubuntu-latest
-    env:
-      OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Cache Docker layers
-        uses: actions/cache@v4
-        with:
-          path: /tmp/.buildx-cache
-          key: ${{ runner.os }}-buildx-${{ github.sha }}
-          restore-keys: |
-            ${{ runner.os }}-buildx-
-
-      - name: Set up Docker
-        run: docker --version && docker-compose --version
-
-      - name: "Create env file"
-        working-directory: ./deploy
-        run: |
-          echo "${{ secrets.ENV_FILE }}" > .env
-
-      - name: Build and start services
-
-        working-directory: ./deploy
-        run: docker compose up --exit-code-from tests tests result_backend broker celeryworker db --build
-        continue-on-error: true
-
-      # - name: Stop services
-      #   run: docker compose down

.github/workflows/create-release.yml

@@ -0,0 +1,64 @@
+name: Create Release
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "Version to release"
+        required: true
+        type: string
+      release_type:
+        description: "Type of release (base or main)"
+        required: true
+        type: choice
+        options:
+          - base
+          - main
+
+env:
+  POETRY_VERSION: "1.8.2"
+jobs:
+  release:
+    name: Build Langflow
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.check-version.outputs.version }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install poetry
+        run: pipx install poetry==${{ env.POETRY_VERSION }}
+      - name: Set up Python 3.12
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+          cache: "poetry"
+      - name: Build project for distribution
+        run: |
+          if [ "${{ inputs.release_type }}" == "base" ]; then
+          make build base=true
+          else
+          make build main=true
+          fi
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist${{ inputs.release_type }}
+          path: ${{ inputs.release_type == 'base' && 'src/backend/base/dist' || 'dist' }}
+  create_release:
+    name: Create Release Job
+    runs-on: ubuntu-latest
+    needs: release
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist${{ inputs.release_type }}
+          path: dist
+      - name: Create Release Notes
+        uses: ncipollo/release-action@v1
+        with:
+          artifacts: "dist/*"
+          token: ${{ secrets.GITHUB_TOKEN }}
+          draft: false
+          generateReleaseNotes: true
+          prerelease: true
+          tag: v${{ inputs.version }}
+          commit: dev

.github/workflows/deploy_gh-pages.yml

@@ -27,7 +27,7 @@ jobs:
       # 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@v3
+        uses: peaceiris/actions-gh-pages@v4
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           # Build output to publish to the `gh-pages` branch:

.github/workflows/docker-build.yml

@@ -0,0 +1,140 @@
+name: Docker Build and Push
+on:
+  workflow_call:
+    inputs:
+      version:
+        required: true
+        type: string
+      release_type:
+        required: true
+        type: string
+      pre_release:
+        required: false
+        type: boolean
+        default: true
+
+  workflow_dispatch:
+    inputs:
+      version:
+        required: true
+        type: string
+      release_type:
+        required: true
+        type: choice
+        options:
+          - base
+          - main
+      pre_release:
+        required: false
+        type: boolean
+        default: true
+env:
+  POETRY_VERSION: "1.8.2"
+  TEST_TAG: "langflowai/langflow:test"
+
+jobs:
+  setup:
+    runs-on: ubuntu-latest
+    outputs:
+      tags: ${{ steps.set-vars.outputs.tags }}
+      file: ${{ steps.set-vars.outputs.file }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set Dockerfile and Tags
+        id: set-vars
+        run: |
+          if [[ "${{ inputs.release_type }}" == "base" ]]; then
+            echo "tags=langflowai/langflow:base-${{ inputs.version }},langflowai/langflow:base-latest" >> $GITHUB_OUTPUT
+            echo "file=./docker/build_and_push_base.Dockerfile" >> $GITHUB_OUTPUT
+          else
+            if [[ "${{ inputs.pre_release }}" == "true" ]]; then
+              echo "tags=langflowai/langflow:${{ inputs.version }}" >> $GITHUB_OUTPUT
+            else
+              echo "tags=langflowai/langflow:${{ inputs.version }},langflowai/langflow:latest" >> $GITHUB_OUTPUT
+            fi
+            echo "file=./docker/build_and_push.Dockerfile" >> $GITHUB_OUTPUT
+          fi
+  build:
+    runs-on: ubuntu-latest
+    needs: setup
+    steps:
+      - uses: actions/checkout@v4
+      - 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 Docker Image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: true
+          file: ${{ needs.setup.outputs.file }}
+          tags: ${{ needs.setup.outputs.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
+
+  build_components:
+    if: ${{ inputs.release_type == 'main' }}
+    runs-on: ubuntu-latest
+    needs: build
+    strategy:
+      matrix:
+        component: [backend, frontend]
+        include:
+          - component: backend
+            dockerfile: ./docker/build_and_push_backend.Dockerfile
+            tags: langflowai/langflow-backend:${{ inputs.version }},langflowai/langflow-backend:1.0-alpha
+          - component: frontend
+            dockerfile: ./docker/frontend/build_and_push_frontend.Dockerfile
+            tags: langflowai/langflow-frontend:${{ inputs.version }},langflowai/langflow-frontend:1.0-alpha
+    steps:
+      - uses: actions/checkout@v4
+      - 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: Wait for Docker Hub to propagate (for backend)
+        run: sleep 120
+      - name: Build and push ${{ matrix.component }}
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: true
+          build-args: |
+            LANGFLOW_IMAGE=langflowai/langflow:${{ inputs.version }}
+          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
+    strategy:
+      matrix:
+        python-version:
+          - "3.12"
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_caching"
+        with:
+          python-version: ${{ matrix.python-version }}
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: ${{ runner.os }}-poetry-${{ env.POETRY_VERSION }}-${{ hashFiles('**/poetry.lock') }}
+      - name: Install Python dependencies
+        run: |
+          poetry env use ${{ matrix.python-version }}
+          poetry install
+
+      - name: Restart HuggingFace Spaces Build
+        run: |
+          poetry run python ./scripts/factory_restart_space.py --space "Langflow/Langflow-Preview" --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.version import __version__ as langflow_version; print(langflow_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.version import __version__ as langflow_version; print(langflow_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/lint-js.yml

@@ -0,0 +1,52 @@
+name: Lint Frontend
+
+on:
+  pull_request:
+    paths:
+      - "src/frontend/**"
+
+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
+
+      - 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 format
+      - name: Commit changes
+        uses: stefanzweifel/git-auto-commit-action@v5
+        with:
+          commit_message: Apply Prettier formatting
+          branch: ${{ github.head_ref }}
+

.github/workflows/lint-py.yml

@@ -0,0 +1,37 @@
+name: Lint Python
+
+on:
+  pull_request:
+    paths:
+      - "poetry.lock"
+      - "pyproject.toml"
+      - "src/backend/**"
+      - "tests/**"
+
+env:
+  POETRY_VERSION: "1.8.2"
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.12"
+          - "3.11"
+          - "3.10"
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_caching"
+        with:
+          python-version: ${{ matrix.python-version }}
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: ${{ runner.os }}-poetry-${{ env.POETRY_VERSION }}-${{ hashFiles('**/poetry.lock') }}
+      - name: Install Python dependencies
+        run: |
+          poetry env use ${{ matrix.python-version }}
+          poetry install
+          make lint
+        env:
+          GITHUB_TOKEN: ${{ secrets.github_token }}

.github/workflows/lint.yml

@@ -1,43 +0,0 @@
-name: lint
-
-on:
-  push:
-    branches: [main]
-    paths:
-      - "poetry.lock"
-      - "pyproject.toml"
-      - "src/backend/**"
-  pull_request:
-    paths:
-      - "poetry.lock"
-      - "pyproject.toml"
-      - "src/backend/**"
-
-env:
-  POETRY_VERSION: "1.7.0"
-
-jobs:
-  lint:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version:
-          - "3.9"
-          - "3.10"
-          - "3.11"
-    steps:
-      - uses: actions/checkout@v4
-      - name: Install poetry
-        run: |
-          pipx install poetry==$POETRY_VERSION
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v5
-        with:
-          python-version: ${{ matrix.python-version }}
-          cache: poetry
-      - name: Install dependencies
-        run: |
-          poetry install
-      - name: Analysing the code with our lint
-        run: |
-          make lint

.github/workflows/matchers/ruff.json

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

.github/workflows/pr-checker.yml

@@ -0,0 +1,26 @@
+name: PR checker
+
+on:
+  pull_request:
+    types: [opened, edited, labeled, unlabeled, synchronize]
+
+jobs:
+  pr-checker:
+    name: Check PR description
+    runs-on: [ubuntu-latest]
+    steps:
+      - name: Run PR title check
+        uses: transferwise/actions-pr-checker@v3
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PR_TITLE_CONTAINS_PATTERN: ".{15,}" # Require at least 10 characters in the title
+          PR_COMMENT: |
+            Please provide a more meaningful PR title with at least 15 characters.
+
+      - name: Run PR description check
+        uses: transferwise/actions-pr-checker@v3
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PR_CONTAINS_PATTERN: ".{25,}" # Require at least 10 characters in the description
+          PR_COMMENT: |
+            Please provide a more meaningful PR description with at least 25 characters.

.github/workflows/pre-release-base.yml

@@ -0,0 +1,80 @@
+name: Langflow Base Pre-release
+run-name: Langflow Base Pre-release by @${{ github.actor }}
+on:
+  workflow_dispatch:
+    inputs:
+      release_package:
+        description: "Release package"
+        required: true
+        type: boolean
+        default: false
+
+env:
+  POETRY_VERSION: "1.8.2"
+
+jobs:
+  release:
+    name: Release Langflow Base
+    if: inputs.release_package == true
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.check-version.outputs.version }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install poetry
+        run: pipx install poetry==${{ env.POETRY_VERSION }}
+      - name: Set up Python 3.10
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+          cache: "poetry"
+      - name: Check Version
+        id: check-version
+        # In this step, we should check the version of the package
+        # and see if it is a version that is already released
+        # echo version=$(cd src/backend/base && poetry version --short) >> $GITHUB_OUTPUT
+        # cd src/backend/base && poetry version --short should
+        # be different than the last release version in pypi
+        # which we can get from curl -s "https://pypi.org/pypi/langflow/json" | jq -r '.releases | keys | .[]' | sort -V | tail -n 1
+        run: |
+          version=$(cd src/backend/base && poetry version --short)
+          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."
+            exit 1
+          else
+            echo version=$version >> $GITHUB_OUTPUT
+          fi
+      - name: Build project for distribution
+        run: make build base=true
+      - name: Publish to PyPI
+        env:
+          POETRY_PYPI_TOKEN_PYPI: ${{ secrets.PYPI_API_TOKEN }}
+        run: |
+          make publish base=true
+  docker_build:
+    name: Build Docker Image
+    runs-on: ubuntu-latest
+    needs: release
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+        id: qemu
+      - 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
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: true
+          file: ./docker/build_and_push_base.Dockerfile
+          tags: |
+            langflowai/langflow:base-${{ needs.release.outputs.version }}
+          # 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

.github/workflows/pre-release-langflow.yml

@@ -0,0 +1,133 @@
+name: Langflow Pre-release
+run-name: Langflow Pre-release by @${{ github.actor }}
+on:
+  workflow_dispatch:
+    inputs:
+      release_package:
+        description: "Release package"
+        required: true
+        type: boolean
+        default: false
+  workflow_run:
+    workflows: ["pre-release-base"]
+    types: [completed]
+    branches: [dev]
+
+env:
+  POETRY_VERSION: "1.8.2"
+
+jobs:
+  release:
+    name: Release Langflow
+    if: inputs.release_package == true
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.check-version.outputs.version }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install poetry
+        run: pipx install poetry==${{ env.POETRY_VERSION }}
+      - name: Set up Python 3.10
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+          cache: "poetry"
+      - name: Check Version
+        id: check-version
+        run: |
+          version=$(poetry version --short)
+          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: Build project for distribution
+        run: make build main=true
+      - name: Display pyproject.toml langflow-base Version
+        run: cat pyproject.toml | grep langflow-base
+      - name: Publish to PyPI
+        env:
+          POETRY_PYPI_TOKEN_PYPI: ${{ secrets.PYPI_API_TOKEN }}
+        run: |
+          make publish main=true
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist
+
+  docker_build:
+    name: Build Docker Image
+    runs-on: ubuntu-latest
+    needs: release
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+        id: qemu
+      - 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
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: true
+          file: ./docker/build_and_push.Dockerfile
+          # 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
+          tags: |
+            langflowai/langflow:${{ needs.release.outputs.version }}
+            langflowai/langflow:1.0-alpha
+      - name: Build and push (frontend)
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: true
+          file: ./docker/frontend/build_and_push_frontend.Dockerfile
+          # 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
+          tags: |
+            langflowai/langflow-frontend:${{ needs.release.outputs.version }}
+            langflowai/langflow-frontend:1.0-alpha
+      - name: Wait for Docker Hub to propagate
+        run: sleep 120
+      - name: Build and push (backend)
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: true
+          file: ./docker/build_and_push_backend.Dockerfile
+          # 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
+          build-args: |
+            LANGFLOW_IMAGE=langflowai/langflow:${{ needs.release.outputs.version }}
+          tags: |
+            langflowai/langflow-backend:${{ needs.release.outputs.version }}
+            langflowai/langflow-backend:1.0-alpha
+
+  create_release:
+    name: Create Release
+    runs-on: ubuntu-latest
+    needs: [docker_build, release]
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist
+      - name: Create Release
+        uses: ncipollo/release-action@v1
+        with:
+          artifacts: "dist/*"
+          token: ${{ secrets.GITHUB_TOKEN }}
+          draft: false
+          generateReleaseNotes: true
+          prerelease: true
+          tag: v${{ needs.release.outputs.version }}
+          commit: dev

.github/workflows/pre-release.yml

@@ -1,37 +1,122 @@
-name: pre-release
-
+name: Langflow Pre-release (Unified)
+run-name: Langflow (${{inputs.release_type}}) Pre-release by @${{ github.actor }}
 on:
-  pull_request:
-    types:
-      - closed
-    branches:
-      - dev
-    paths:
-      - "pyproject.toml"
   workflow_dispatch:
+    inputs:
+      release_package:
+        description: "Release package"
+        required: true
+        type: boolean
+        default: false
+      release_type:
+        description: "Type of release (base or main)"
+        required: true
+        type: choice
+        options:
+          - base
+          - main
 
 env:
-  POETRY_VERSION: "1.5.1"
+  POETRY_VERSION: "1.8.2"
 
 jobs:
-  if_release:
-    if: ${{ (github.event.pull_request.merged == true) && contains(github.event.pull_request.labels.*.name, 'pre-release') }}
+  release:
+    name: Release Langflow
+    if: inputs.release_package == true
     runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.check-version.outputs.version }}
     steps:
       - uses: actions/checkout@v4
       - name: Install poetry
-        run: pipx install poetry==$POETRY_VERSION
+        run: pipx install poetry==${{ env.POETRY_VERSION }}
       - name: Set up Python 3.10
         uses: actions/setup-python@v5
         with:
           python-version: "3.10"
           cache: "poetry"
-      - name: Build project for distribution
-        run: make build
+      - name: Set up Nodejs 20
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
       - name: Check Version
         id: check-version
         run: |
-          echo version=$(poetry version --short) >> $GITHUB_OUTPUT
+          if [ "${{ inputs.release_type }}" == "base" ]; then
+            version=$(cd src/backend/base && poetry version --short)
+            last_released_version=$(curl -s "https://pypi.org/pypi/langflow-base/json" | jq -r '.releases | keys | .[]' | sort -V | tail -n 1)
+          else
+            version=$(poetry version --short)
+            last_released_version=$(curl -s "https://pypi.org/pypi/langflow/json" | jq -r '.releases | keys | .[]' | sort -V | tail -n 1)
+          fi
+          if [ "$version" = "$last_released_version" ]; then
+            echo "Version $version is already released. Skipping release."
+            exit 1
+          else
+            echo version=$version >> $GITHUB_OUTPUT
+          fi
+      - name: Build project for distribution
+        run: |
+          if [ "${{ inputs.release_type }}" == "base" ]; then
+            make build base=true
+          else
+            make build main=true
+          fi
+      - name: Test CLI
+        run: |
+          if [ "${{ inputs.release_type }}" == "base" ]; then
+            python -m pip install src/backend/base/dist/*.whl
+          else
+            python -m pip install dist/*.whl
+          fi
+          python -m langflow run --host 127.0.0.1 --port 7860 &
+          SERVER_PID=$!
+          # Wait for the server to start
+          timeout 120 bash -c 'until curl -f http://127.0.0.1:7860/health; 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 10 # 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 1
+          else
+            echo "Server terminated successfully"
+          fi
+      - name: Publish to PyPI
+        env:
+          POETRY_PYPI_TOKEN_PYPI: ${{ secrets.PYPI_API_TOKEN }}
+        run: |
+          if [ "${{ inputs.release_type }}" == "base" ]; then
+            make publish base=true
+          else
+            make publish main=true
+          fi
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist${{ inputs.release_type }}
+          path: ${{ inputs.release_type == 'base' && 'src/backend/base/dist' || 'dist' }}
+
+  call_docker_build:
+    name: Call Docker Build Workflow
+    needs: release
+    uses: langflow-ai/langflow/.github/workflows/docker-build.yml@dev
+    with:
+      version: ${{ needs.release.outputs.version }}
+      release_type: ${{ inputs.release_type }}
+    secrets: inherit
+
+  create_release:
+    name: Create Release
+    runs-on: ubuntu-latest
+    needs: [release]
+    if: ${{ inputs.release_type == 'main' }}
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist${{ inputs.release_type }}
+          path: dist
       - name: Create Release
         uses: ncipollo/release-action@v1
         with:
@@ -40,26 +125,5 @@ jobs:
           draft: false
           generateReleaseNotes: true
           prerelease: true
-          tag: v${{ steps.check-version.outputs.version }}
+          tag: v${{ needs.release.outputs.version }}
           commit: dev
-      - name: Publish to PyPI
-        env:
-          POETRY_PYPI_TOKEN_PYPI: ${{ secrets.PYPI_API_TOKEN }}
-        run: |
-          poetry publish
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-      - 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
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          push: true
-          file: ./build_and_push.Dockerfile
-          tags: logspace/langflow:${{ steps.check-version.outputs.version }}

.github/workflows/python_test.yml

@@ -0,0 +1,45 @@
+name: test
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - "poetry.lock"
+      - "pyproject.toml"
+      - "src/backend/**"
+  pull_request:
+    branches: [dev]
+    paths:
+      - "poetry.lock"
+      - "pyproject.toml"
+      - "src/backend/**"
+
+env:
+  POETRY_VERSION: "1.8.2"
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version:
+          - "3.12"
+          - "3.11"
+          - "3.10"
+    env:
+      OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python ${{ matrix.python-version }} + Poetry ${{ env.POETRY_VERSION }}
+        uses: "./.github/actions/poetry_caching"
+        with:
+          python-version: ${{ matrix.python-version }}
+          poetry-version: ${{ env.POETRY_VERSION }}
+          cache-key: ${{ runner.os }}-poetry-${{ env.POETRY_VERSION }}-${{ hashFiles('**/poetry.lock') }}
+      - name: Install Python dependencies
+        run: |
+          poetry env use ${{ matrix.python-version }}
+          poetry install
+      - name: Run unit tests
+        run: |
+          make unit_tests args="-n auto"