Merge remote-tracking branch 'origin/dev' into add_session_id

2023-08-16 19:31:29 -03:00 · 2023-08-16 19:31:29 -03:00 · 2f928c7d84
commit 2f928c7d84
parent 6af7d04d4e 479db46fcf
220 changed files with 9415 additions and 4567 deletions
--- a/.dockerignore
+++ b/.dockerignore
@ -0,0 +1 @@
+.venv/
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@ -1,4 +1,5 @@
 {
+  "version": "0.2.0",
  "configurations": [
    {
      "name": "Debug Backend",
@ -38,6 +39,15 @@
      "request": "launch",
      "url": "http://localhost:3000/",
      "webRoot": "${workspaceRoot}/src/frontend"
+    },
+    {
+      "name": "Python: Debug Tests",
+      "type": "python",
+      "request": "launch",
+      "program": "${file}",
+      "purpose": ["debug-test"],
+      "console": "integratedTerminal",
+      "justMyCode": false
    }
  ]
 }
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -7,6 +7,11 @@ to contributions, whether it be in the form of a new feature, improved infra, or
 To contribute to this project, please follow a ["fork and pull request"](https://docs.github.com/en/get-started/quickstart/contributing-to-projects) workflow.
 Please do not try to push directly to this repo unless you are a maintainer.

+The branch structure is as follows:
+
+- `main`: The stable version of Langflow
+- `dev`: The development version of Langflow. This branch is used to test new features before they are merged into `main` and, as such, may be unstable.
+
 ## 🗺️Contributing Guidelines

 ## 🚩GitHub Issues
--- a/9
+++ b/9
@ -32,7 +32,10 @@ lint:
 	poetry run ruff . --fix

 install_frontend:
-	cd src/frontend && npm install
+		cd src/frontend && npm install;
+
+install_frontendc:
+		cd src/frontend && npm ci;

 run_frontend:
 	cd src/frontend && npm start
@ -40,6 +43,10 @@ run_frontend:
 frontend:
 	make install_frontend
 	make run_frontend
+	
+frontendc:
+	make install_frontendc
+	make run_frontend

 install_backend:
 	poetry install
--- a/README.md
+++ b/README.md
@ -275,6 +275,8 @@ flow("Hey, have you heard of Langflow?")

 We welcome contributions from developers of all levels to our open-source project on GitHub. If you'd like to contribute, please check our [contributing guidelines](./CONTRIBUTING.md) and help make Langflow more accessible.

+---
+
 Join our [Discord](https://discord.com/invite/EqksyE2EX9) server to ask questions, make suggestions and showcase your projects! 🦾

 <p>
--- a/dev.Dockerfile
+++ b/dev.Dockerfile
@ -15,4 +15,4 @@ COPY ./ ./
 # Install dependencies
 RUN poetry config virtualenvs.create false && poetry install --no-interaction --no-ansi

-CMD ["uvicorn", "langflow.main:app", "--host", "0.0.0.0", "--port", "5003", "--reload", "log-level", "debug"]
+CMD ["uvicorn", "--factory", "src.backend.langflow.main:create_app", "--host", "0.0.0.0", "--port", "7860", "--reload", "--log-level", "debug"]
--- a/docker-compose.debug.yml
+++ b/docker-compose.debug.yml
@ -1,4 +1,4 @@
-version: '3.4'
+version: "3.4"

 services:
  backend:
@ -7,7 +7,12 @@ services:
    build:
      context: ./
      dockerfile: ./dev.Dockerfile
-    command: ["sh", "-c", "pip install debugpy -t /tmp && python /tmp/debugpy --wait-for-client --listen 0.0.0.0:5678 -m uvicorn langflow.main:app --host 0.0.0.0 --port 7860 --reload"]
+    command:
+      [
+        "sh",
+        "-c",
+        "pip install debugpy -t /tmp && python /tmp/debugpy --wait-for-client --listen 0.0.0.0:5678 -m uvicorn --factory src.backend.langflow.main:create_app --host 0.0.0.0 --port 7860 --reload",
+      ]
    ports:
      - 7860:7860
      - 5678:5678
@ -22,7 +27,7 @@ services:
    ports:
      - "3000:3000"
    volumes:
-     - ./src/frontend/public:/home/node/app/public
-     - ./src/frontend/src:/home/node/app/src
-     - ./src/frontend/package.json:/home/node/app/package.json
-    restart: on-failure
+      - ./src/frontend/public:/home/node/app/public
+      - ./src/frontend/src:/home/node/app/src
+      - ./src/frontend/package.json:/home/node/app/package.json
+    restart: on-failure
--- a/docker-compose.yml
+++ b/docker-compose.yml
@ -1,4 +1,4 @@
-version: '3'
+version: "3"

 services:
  backend:
@ -9,7 +9,7 @@ services:
      - "7860:7860"
    volumes:
      - ./:/app
-    command: bash -c "uvicorn langflow.main:app --host 0.0.0.0 --port 7860 --reload"
+    command: bash -c "uvicorn --factory src.backend.langflow.main:create_app --host 0.0.0.0 --port 7860 --reload"

  frontend:
    build:
@ -22,7 +22,7 @@ services:
    ports:
      - "3000:3000"
    volumes:
-     - ./src/frontend/public:/home/node/app/public
-     - ./src/frontend/src:/home/node/app/src
-     - ./src/frontend/package.json:/home/node/app/package.json
-    restart: on-failure
+      - ./src/frontend/public:/home/node/app/public
+      - ./src/frontend/src:/home/node/app/src
+      - ./src/frontend/package.json:/home/node/app/package.json
+    restart: on-failure
--- a/docker_example/docker-compose.yml
+++ b/docker_example/docker-compose.yml
@ -6,5 +6,5 @@ services:
      context: .
      dockerfile: Dockerfile
    ports:
-      - "5003:5003"
+      - "7860:7860"
    command: langflow --host 0.0.0.0
--- a/docs/docs/components/embeddings.mdx
+++ b/docs/docs/components/embeddings.mdx
@ -73,3 +73,25 @@ Used to load [OpenAI’s](https://openai.com/) embedding models.
 - **request_timeout:** Used to specify the maximum amount of time, in milliseconds, to wait for a response from the OpenAI API when generating embeddings for a given text.

 - **tiktoken_model_name:** Used to count the number of tokens in documents to constrain them to be under a certain limit. By default, when set to None, this will be the same as the embedding model name.
+
+---
+
+### VertexAIEmbeddings
+
+Wrapper around [Google Vertex AI](https://cloud.google.com/vertex-ai) [Embeddings API](https://cloud.google.com/vertex-ai/docs/generative-ai/embeddings/get-text-embeddings).
+
+:::info
+Vertex AI is a cloud computing platform offered by Google Cloud Platform (GCP). It provides access, management, and development of applications and services through global data centers. To use Vertex AI PaLM, you need to have the [google-cloud-aiplatform](https://pypi.org/project/google-cloud-aiplatform/) Python package installed and credentials configured for your environment.
+:::
+
+- **credentials:** The default custom credentials (google.auth.credentials.Credentials) to use.
+- **location:** The default location to use when making API calls – defaults to `us-central1`.
+- **max_output_tokens:** Token limit determines the maximum amount of text output from one prompt – defaults to `128`.
+- **model_name:** The name of the Vertex AI large language model – defaults to `text-bison`.
+- **project:** The default GCP project to use when making Vertex API calls.
+- **request_parallelism:** The amount of parallelism allowed for requests issued to VertexAI models – defaults to `5`.
+- **temperature:** Tunes the degree of randomness in text generations. Should be a non-negative value – defaults to `0`.
+- **top_k:** How the model selects tokens for output, the next token is selected from – defaults to `40`.
+- **top_p:** Tokens are selected from most probable to least until the sum of their – defaults to `0.95`.
+- **tuned_model_name:** The name of a tuned model. If provided, model_name is ignored.
+- **verbose:** This parameter is used to control the level of detail in the output of the chain. When set to True, it will print out some internal states of the chain while it is being run, which can help debug and understand the chain's behavior. If set to False, it will suppress the verbose output – defaults to `False`.
--- a/docs/docs/components/llms.mdx
+++ b/docs/docs/components/llms.mdx
@ -185,6 +185,28 @@ Wrapper around [Google Vertex AI](https://cloud.google.com/vertex-ai) large lang
 Vertex AI is a cloud computing platform offered by Google Cloud Platform (GCP). It provides access, management, and development of applications and services through global data centers. To use Vertex AI PaLM, you need to have the [google-cloud-aiplatform](https://pypi.org/project/google-cloud-aiplatform/) Python package installed and credentials configured for your environment.
 :::

+- **credentials:** The default custom credentials (google.auth.credentials.Credentials) to use.
+- **location:** The default location to use when making API calls – defaults to `us-central1`.
+- **max_output_tokens:** Token limit determines the maximum amount of text output from one prompt – defaults to `128`.
+- **model_name:** The name of the Vertex AI large language model – defaults to `text-bison`.
+- **project:** The default GCP project to use when making Vertex API calls.
+- **request_parallelism:** The amount of parallelism allowed for requests issued to VertexAI models – defaults to `5`.
+- **temperature:** Tunes the degree of randomness in text generations. Should be a non-negative value – defaults to `0`.
+- **top_k:** How the model selects tokens for output, the next token is selected from – defaults to `40`.
+- **top_p:** Tokens are selected from most probable to least until the sum of their – defaults to `0.95`.
+- **tuned_model_name:** The name of a tuned model. If provided, model_name is ignored.
+- **verbose:** This parameter is used to control the level of detail in the output of the chain. When set to True, it will print out some internal states of the chain while it is being run, which can help debug and understand the chain's behavior. If set to False, it will suppress the verbose output – defaults to `False`.
+
+---
+
+### ChatVertexAI
+
+Wrapper around [Google Vertex AI](https://cloud.google.com/vertex-ai) large language models.
+
+:::info
+Vertex AI is a cloud computing platform offered by Google Cloud Platform (GCP). It provides access, management, and development of applications and services through global data centers. To use Vertex AI PaLM, you need to have the [google-cloud-aiplatform](https://pypi.org/project/google-cloud-aiplatform/) Python package installed and credentials configured for your environment.
+:::
+
 - **credentials:** The default custom credentials (google.auth.credentials.Credentials) to use.
 - **location:** The default location to use when making API calls – defaults to `us-central1`.
 - **max_output_tokens:** Token limit determines the maximum amount of text output from one prompt – defaults to `128`.
--- a/docs/docs/guidelines/custom-component.mdx
+++ b/docs/docs/guidelines/custom-component.mdx
@ -65,7 +65,6 @@ class DocumentProcessor(CustomComponent):
        light: "img/document_processor.png",
    }}
    style={{
-        width: "40%",
        margin: "0 auto",
        display: "flex",
        justifyContent: "center",
--- a/docs/docs/guides/loading_document.mdx
+++ b/docs/docs/guides/loading_document.mdx
@ -43,7 +43,7 @@ This guide takes you through the process of augmenting the "Basic Chat with Prom

 8. Connect this loader to the `{context}` variable that we just added.

-9. In the "Web Page" field, enter "https://langflow.org/how-upload-examples".
+9. In the "Web Page" field, enter "https://docs.langflow.org/how-upload-examples".

 10. Now, click on "ConversationBufferMemory".

--- a/docs/static/CNAME
+++ b/docs/static/CNAME
@ -1 +1 @@
-langflow.org
+docs.langflow.org
--- a/package-lock.json
+++ b/package-lock.json
@ -1,5 +1,5 @@
 {
-  "name": "langflow",
+  "name": "reactFlow",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
--- a/poetry.lock
+++ b/poetry.lock
--- a/pyproject.toml
+++ b/pyproject.toml
@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langflow"
-version = "0.4.2"
+version = "0.4.7"
 description = "A Python package with a built-in web application"
 authors = ["Logspace <contact@logspace.ai>"]
 maintainers = [
@ -19,7 +19,7 @@ readme = "README.md"
 keywords = ["nlp", "langchain", "openai", "gpt", "gui"]
 packages = [{ include = "langflow", from = "src/backend" }]
 include = ["src/backend/langflow/*", "src/backend/langflow/**/*"]
-
+documentation = "https://docs.langflow.org"

 [tool.poetry.scripts]
 langflow = "langflow.__main__:main"
@ -45,7 +45,7 @@ unstructured = "^0.7.0"
 pypdf = "^3.11.0"
 lxml = "^4.9.2"
 pysrt = "^1.1.2"
-fake-useragent = "^1.1.3"
+fake-useragent = "^1.2.1"
 docstring-parser = "^0.15"
 psycopg2-binary = "^2.9.6"
 pyarrow = "^12.0.0"
@ -63,7 +63,7 @@ python-multipart = "^0.0.6"
 sqlmodel = "^0.0.8"
 faiss-cpu = "^1.7.4"
 anthropic = "^0.3.0"
-orjson = "^3.9.1"
+orjson = "3.9.3"
 multiprocess = "^0.70.14"
 cachetools = "^5.3.1"
 types-cachetools = "^5.3.0.5"
@ -77,6 +77,11 @@ psycopg = "^3.1.9"
 psycopg-binary = "^3.1.9"
 fastavro = "^1.8.0"
 langchain-experimental = "^0.0.8"
+alembic = "^1.11.2"
+passlib = "^1.7.4"
+bcrypt = "^4.0.1"
+python-jose = "^3.3.0"
+metaphor-python = "^0.1.11"

 [tool.poetry.group.dev.dependencies]
 black = "^23.1.0"
--- a/src/backend/Dockerfile
+++ b/src/backend/Dockerfile
@ -11,4 +11,4 @@ RUN rm *.whl

 EXPOSE 80

-CMD [ "uvicorn", "--host", "0.0.0.0", "--port", "80", "langflow.backend.app:app" ]
+CMD [ "uvicorn", "--host", "0.0.0.0", "--port", "7860", "--factory", "langflow.main:create_app" ]
--- a/src/backend/langflow/init.py
+++ b/src/backend/langflow/init.py
@ -1,5 +1,7 @@
 from importlib import metadata
-from langflow.cache import cache_manager
+
+# Deactivate cache manager for now
+# from langflow.services.cache import cache_manager
 from langflow.processing.process import load_flow_from_json
 from langflow.interface.custom.custom_component import CustomComponent

--- a/src/backend/langflow/main.py
+++ b/src/backend/langflow/main.py
@ -1,6 +1,7 @@
 import sys
 import time
 import httpx
+from langflow.services.utils import get_settings_manager
 from langflow.utils.util import get_number_of_workers
 from multiprocess import Process  # type: ignore
 import platform
@ -12,7 +13,6 @@ from rich import box
 from rich import print as rprint
 import typer
 from langflow.main import setup_app
-from langflow.settings import settings
 from langflow.utils.logger import configure, logger
 import webbrowser
 from dotenv import load_dotenv
@ -30,19 +30,19 @@ def update_settings(
    """Update the settings from a config file."""

    # Check for database_url in the environment variables
-
+    settings_manager = get_settings_manager()
    if config:
        logger.debug(f"Loading settings from {config}")
-        settings.update_from_yaml(config, dev=dev)
+        settings_manager.settings.update_from_yaml(config, dev=dev)
    if remove_api_keys:
        logger.debug(f"Setting remove_api_keys to {remove_api_keys}")
-        settings.update_settings(REMOVE_API_KEYS=remove_api_keys)
+        settings_manager.settings.update_settings(REMOVE_API_KEYS=remove_api_keys)
    if cache:
        logger.debug(f"Setting cache to {cache}")
-        settings.update_settings(CACHE=cache)
+        settings_manager.settings.update_settings(CACHE=cache)
    if components_path:
        logger.debug(f"Adding component path {components_path}")
-        settings.update_settings(COMPONENTS_PATH=components_path)
+        settings_manager.settings.update_settings(COMPONENTS_PATH=components_path)


 def serve_on_jcloud():
@ -106,7 +106,9 @@ def serve(
        help="Path to the directory containing custom components.",
        envvar="LANGFLOW_COMPONENTS_PATH",
    ),
-    config: str = typer.Option("config.yaml", help="Path to the configuration file."),
+    config: str = typer.Option(
+        Path(__file__).parent / "config.yaml", help="Path to the configuration file."
+    ),
    # .env file param
    env_file: Path = typer.Option(
        None, help="Path to the .env file containing environment variables."
@ -146,6 +148,11 @@ def serve(
        help="Remove API keys from the projects saved in the database.",
        envvar="LANGFLOW_REMOVE_API_KEYS",
    ),
+    backend_only: bool = typer.Option(
+        False,
+        help="Run only the backend server without the frontend.",
+        envvar="LANGFLOW_BACKEND_ONLY",
+    ),
 ):
    """
    Run the Langflow server.
@ -167,7 +174,7 @@ def serve(
    )
    # create path object if path is provided
    static_files_dir: Optional[Path] = Path(path) if path else None
-    app = setup_app(static_files_dir=static_files_dir)
+    app = setup_app(static_files_dir=static_files_dir, backend_only=backend_only)
    # check if port is being used
    if is_port_in_use(port, host):
        port = get_free_port(port)
@ -179,6 +186,10 @@ def serve(
        "timeout": timeout,
    }

+    # Define an env variable to know if we are just testing the server
+    if "pytest" in sys.modules:
+        return
+
    if platform.system() in ["Windows"]:
        # Run using uvicorn on MacOS and Windows
        # Windows doesn't support gunicorn
--- a/src/backend/langflow/alembic.ini
+++ b/src/backend/langflow/alembic.ini
@ -0,0 +1,113 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts
+script_location = alembic
+
+# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
+# Uncomment the line below if you want the files to be prepended with date and time
+# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
+# for all available tokens
+# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.
+prepend_sys_path = .
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the python-dateutil library that can be
+# installed by adding `alembic[tz]` to the pip requirements
+# string value is passed to dateutil.tz.gettz()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the
+# "slug" field
+# truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; This defaults
+# to alembic/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path.
+# The path separator used here should be the separator specified by "version_path_separator" below.
+# version_locations = %(here)s/bar:%(here)s/bat:alembic/versions
+
+# version path separator; As mentioned above, this is the character used to split
+# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
+# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
+# Valid values for version_path_separator are:
+#
+# version_path_separator = :
+# version_path_separator = ;
+# version_path_separator = space
+version_path_separator = os  # Use os.pathsep. Default configuration used for new projects.
+
+# set to 'true' to search source files recursively
+# in each "version_locations" directory
+# new in Alembic version 1.10
+# recursive_version_locations = false
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+# This is the path to the db in the root of the project.
+# When the user runs the Langflow the database url will
+# be set dinamically.
+sqlalchemy.url = sqlite:///../../../langflow.db
+
+
+[post_write_hooks]
+# post_write_hooks defines scripts or Python functions that are run
+# on newly generated revision scripts.  See the documentation for further
+# detail and examples
+
+# format using "black" - use the console_scripts runner, against the "black" entrypoint
+# hooks = black
+# black.type = console_scripts
+# black.entrypoint = black
+# black.options = -l 79 REVISION_SCRIPT_FILENAME
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S
--- a/src/backend/langflow/alembic/README
+++ b/src/backend/langflow/alembic/README
@ -0,0 +1 @@
+Generic single-database configuration.
--- a/src/backend/langflow/alembic/env.py
+++ b/src/backend/langflow/alembic/env.py
@ -0,0 +1,78 @@
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+
+from langflow.services.database.manager import SQLModel
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+target_metadata = SQLModel.metadata
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(connection=connection, target_metadata=target_metadata)
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()
--- a/src/backend/langflow/alembic/script.py.mako
+++ b/src/backend/langflow/alembic/script.py.mako
@ -0,0 +1,27 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    ${downgrades if downgrades else "pass"}
--- a/src/backend/langflow/alembic/versions/0a534bdfd84b_remove_flowstyles_table.py
+++ b/src/backend/langflow/alembic/versions/0a534bdfd84b_remove_flowstyles_table.py
@ -0,0 +1,42 @@
+"""Remove FlowStyles table
+
+Revision ID: 0a534bdfd84b
+Revises: 4814b6f4abfd
+Create Date: 2023-08-07 14:09:06.844104
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = "0a534bdfd84b"
+down_revision: Union[str, None] = "4814b6f4abfd"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table("flowstyle")
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table(
+        "flowstyle",
+        sa.Column("color", sa.VARCHAR(), nullable=False),
+        sa.Column("emoji", sa.VARCHAR(), nullable=False),
+        sa.Column("flow_id", sa.CHAR(length=32), nullable=True),
+        sa.Column("id", sa.CHAR(length=32), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["flow_id"],
+            ["flow.id"],
+        ),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("id"),
+    )
+    # ### end Alembic commands ###
--- a/src/backend/langflow/alembic/versions/4814b6f4abfd_add_flow_table.py
+++ b/src/backend/langflow/alembic/versions/4814b6f4abfd_add_flow_table.py
@ -0,0 +1,65 @@
+"""Add Flow table
+
+Revision ID: 4814b6f4abfd
+Revises:
+Create Date: 2023-08-05 17:47:42.879824
+
+"""
+
+import contextlib
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel
+
+
+# revision identifiers, used by Alembic.
+revision: str = "4814b6f4abfd"
+down_revision: Union[str, None] = None
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+
+    # This suppress is used to not break the migration if the table already exists.
+    with contextlib.suppress(sa.exc.OperationalError):
+        op.create_table(
+            "flow",
+            sa.Column("data", sa.JSON(), nullable=True),
+            sa.Column("name", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+            sa.Column("description", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+            sa.Column("id", sqlmodel.sql.sqltypes.GUID(), nullable=False),
+            sa.PrimaryKeyConstraint("id"),
+            sa.UniqueConstraint("id"),
+        )
+        op.create_index(
+            op.f("ix_flow_description"), "flow", ["description"], unique=False
+        )
+        op.create_index(op.f("ix_flow_name"), "flow", ["name"], unique=False)
+    with contextlib.suppress(sa.exc.OperationalError):
+        op.create_table(
+            "flowstyle",
+            sa.Column("color", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+            sa.Column("emoji", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+            sa.Column("flow_id", sqlmodel.sql.sqltypes.GUID(), nullable=True),
+            sa.Column("id", sqlmodel.sql.sqltypes.GUID(), nullable=False),
+            sa.ForeignKeyConstraint(
+                ["flow_id"],
+                ["flow.id"],
+            ),
+            sa.PrimaryKeyConstraint("id"),
+            sa.UniqueConstraint("id"),
+        )
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table("flowstyle")
+    op.drop_index(op.f("ix_flow_name"), table_name="flow")
+    op.drop_index(op.f("ix_flow_description"), table_name="flow")
+    op.drop_table("flow")
+    # ### end Alembic commands ###
--- a/src/backend/langflow/api/router.py
+++ b/src/backend/langflow/api/router.py
@ -5,7 +5,6 @@ from langflow.api.v1 import (
    endpoints_router,
    validate_router,
    flows_router,
-    flow_styles_router,
    component_router,
 )

@ -17,4 +16,3 @@ router.include_router(endpoints_router)
 router.include_router(validate_router)
 router.include_router(component_router)
 router.include_router(flows_router)
-router.include_router(flow_styles_router)
--- a/src/backend/langflow/api/v1/init.py
+++ b/src/backend/langflow/api/v1/init.py
@ -2,7 +2,6 @@ from langflow.api.v1.endpoints import router as endpoints_router
 from langflow.api.v1.validate import router as validate_router
 from langflow.api.v1.chat import router as chat_router
 from langflow.api.v1.flows import router as flows_router
-from langflow.api.v1.flow_styles import router as flow_styles_router
 from langflow.api.v1.components import router as component_router

 __all__ = [
@ -11,5 +10,4 @@ __all__ = [
    "component_router",
    "validate_router",
    "flows_router",
-    "flow_styles_router",
 ]
--- a/src/backend/langflow/api/v1/chat.py
+++ b/src/backend/langflow/api/v1/chat.py
@ -3,13 +3,13 @@ from fastapi.responses import StreamingResponse
 from langflow.api.utils import build_input_keys_response
 from langflow.api.v1.schemas import BuildStatus, BuiltResponse, InitResponse, StreamData

-from langflow.chat.manager import ChatManager
+from langflow.services import service_manager, ServiceType
 from langflow.graph.graph.base import Graph
 from langflow.utils.logger import logger
 from cachetools import LRUCache

 router = APIRouter(tags=["Chat"])
-chat_manager = ChatManager()
+
 flow_data_store: LRUCache = LRUCache(maxsize=10)


@ -17,6 +17,7 @@ flow_data_store: LRUCache = LRUCache(maxsize=10)
 async def chat(client_id: str, websocket: WebSocket):
    """Websocket endpoint for chat."""
    try:
+        chat_manager = service_manager.get(ServiceType.CHAT_MANAGER)
        if client_id in chat_manager.in_memory_cache:
            await chat_manager.handle_websocket(client_id, websocket)
        else:
@ -45,6 +46,7 @@ async def init_build(graph_data: dict, flow_id: str):
            return InitResponse(flowId=flow_id)

        # Delete from cache if already exists
+        chat_manager = service_manager.get(ServiceType.CHAT_MANAGER)
        if flow_id in chat_manager.in_memory_cache:
            with chat_manager.in_memory_cache._lock:
                chat_manager.in_memory_cache.delete(flow_id)
@ -155,12 +157,12 @@ async def stream_build(flow_id: str):
                )
            else:
                input_keys_response = {
-                    "input_keys": {},
+                    "input_keys": None,
                    "memory_keys": [],
                    "handle_keys": [],
                }
            yield str(StreamData(event="message", data=input_keys_response))
-
+            chat_manager = service_manager.get(ServiceType.CHAT_MANAGER)
            chat_manager.set_cache(flow_id, langchain_object)
            # We need to reset the chat history
            chat_manager.chat_history.empty_history(flow_id)
--- a/src/backend/langflow/api/v1/components.py
+++ b/src/backend/langflow/api/v1/components.py
@ -1,8 +1,8 @@
 from datetime import timezone
 from typing import List
 from uuid import UUID
-from langflow.database.models.component import Component, ComponentModel
-from langflow.database.base import get_session
+from langflow.services.database.models.component import Component, ComponentModel
+from langflow.services.utils import get_session
 from sqlmodel import Session, select
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.exc import IntegrityError
--- a/src/backend/langflow/api/v1/endpoints.py
+++ b/src/backend/langflow/api/v1/endpoints.py
@ -1,12 +1,11 @@
 from http import HTTPStatus
 from typing import Annotated, Optional

-from langflow.cache.utils import save_uploaded_file
-from langflow.database.models.flow import Flow
+from langflow.services.cache.utils import save_uploaded_file
+from langflow.services.database.models.flow import Flow
 from langflow.processing.process import process_graph_cached, process_tweaks
+from langflow.services.utils import get_settings_manager
 from langflow.utils.logger import logger
-from langflow.settings import settings
-
 from fastapi import APIRouter, Depends, HTTPException, UploadFile, Body

 from langflow.interface.custom.custom_component import CustomComponent
@ -26,7 +25,7 @@ from langflow.interface.types import (
    build_langchain_custom_component_list_from_path,
 )

-from langflow.database.base import get_session
+from langflow.services.utils import get_session
 from sqlmodel import Session

 # build router
@ -40,15 +39,20 @@ def get_all():
    # custom_components is a list of dicts
    # need to merge all the keys into one dict
    custom_components_from_file = {}
-    if settings.COMPONENTS_PATH:
-        logger.info(f"Building custom components from {settings.COMPONENTS_PATH}")
+    settings_manager = get_settings_manager()
+    if settings_manager.settings.COMPONENTS_PATH:
+        logger.info(
+            f"Building custom components from {settings_manager.settings.COMPONENTS_PATH}"
+        )
        custom_component_dicts = [
            build_langchain_custom_component_list_from_path(str(path))
-            for path in settings.COMPONENTS_PATH
+            for path in settings_manager.settings.COMPONENTS_PATH
        ]
        logger.info(f"Loading {len(custom_component_dicts)} category(ies)")
        for custom_component_dict in custom_component_dicts:
            # custom_component_dict is a dict of dicts
+            if not custom_component_dict:
+                continue
            category = list(custom_component_dict.keys())[0]
            logger.info(
                f"Loading {len(custom_component_dict[category])} component(s) from category {category}"
--- a/src/backend/langflow/api/v1/flow_styles.py
+++ b/src/backend/langflow/api/v1/flow_styles.py
@ -1,83 +0,0 @@
-from uuid import UUID
-from langflow.database.models.flow_style import (
-    FlowStyle,
-    FlowStyleCreate,
-    FlowStyleRead,
-    FlowStyleUpdate,
-)
-from langflow.database.base import get_session
-from sqlmodel import Session, select
-from fastapi import APIRouter, Depends, HTTPException
-
-
-# build router
-router = APIRouter(prefix="/flow_styles", tags=["FlowStyles"])
-
-# FlowStyleCreate:
-# class FlowStyleBase(SQLModel):
-#     color: str = Field(index=True)
-#     emoji: str = Field(index=False)
-#     flow_id: UUID = Field(default=None, foreign_key="flow.id")
-
-
-@router.post("/", response_model=FlowStyleRead)
-def create_flow_style(
-    *, session: Session = Depends(get_session), flow_style: FlowStyleCreate
-):
-    """Create a new flow_style."""
-    db_flow_style = FlowStyle.from_orm(flow_style)
-    session.add(db_flow_style)
-    session.commit()
-    session.refresh(db_flow_style)
-    return db_flow_style
-
-
-@router.get("/", response_model=list[FlowStyleRead])
-def read_flow_styles(*, session: Session = Depends(get_session)):
-    """Read all flows."""
-    try:
-        flows = session.exec(select(FlowStyle)).all()
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e)) from e
-    return flows
-
-
-@router.get("/{flow_styles_id}", response_model=FlowStyleRead)
-def read_flow_style(*, session: Session = Depends(get_session), flow_styles_id: UUID):
-    """Read a flow_style."""
-    if flow_style := session.get(FlowStyle, flow_styles_id):
-        return flow_style
-    else:
-        raise HTTPException(status_code=404, detail="FlowStyle not found")
-
-
-@router.patch("/{flow_style_id}", response_model=FlowStyleRead)
-def update_flow_style(
-    *,
-    session: Session = Depends(get_session),
-    flow_style_id: UUID,
-    flow_style: FlowStyleUpdate,
-):
-    """Update a flow_style."""
-    db_flow_style = session.get(FlowStyle, flow_style_id)
-    if not db_flow_style:
-        raise HTTPException(status_code=404, detail="FlowStyle not found")
-    flow_data = flow_style.dict(exclude_unset=True)
-    for key, value in flow_data.items():
-        if hasattr(db_flow_style, key) and value is not None:
-            setattr(db_flow_style, key, value)
-    session.add(db_flow_style)
-    session.commit()
-    session.refresh(db_flow_style)
-    return db_flow_style
-
-
-@router.delete("/{flow_id}")
-def delete_flow_style(*, session: Session = Depends(get_session), flow_id: UUID):
-    """Delete a flow_style."""
-    flow_style = session.get(FlowStyle, flow_id)
-    if not flow_style:
-        raise HTTPException(status_code=404, detail="FlowStyle not found")
-    session.delete(flow_style)
-    session.commit()
-    return {"message": "FlowStyle deleted successfully"}
--- a/src/backend/langflow/api/v1/flows.py
+++ b/src/backend/langflow/api/v1/flows.py
@ -1,16 +1,15 @@
 from typing import List
 from uuid import UUID
-from langflow.settings import settings
 from langflow.api.utils import remove_api_keys
 from langflow.api.v1.schemas import FlowListCreate, FlowListRead
-from langflow.database.models.flow import (
+from langflow.services.database.models.flow import (
    Flow,
    FlowCreate,
    FlowRead,
-    FlowReadWithStyle,
    FlowUpdate,
 )
-from langflow.database.base import get_session
+from langflow.services.utils import get_session
+from langflow.services.utils import get_settings_manager
 from sqlmodel import Session, select
 from fastapi import APIRouter, Depends, HTTPException
 from fastapi.encoders import jsonable_encoder
@ -32,7 +31,7 @@ def create_flow(*, session: Session = Depends(get_session), flow: FlowCreate):
    return db_flow


-@router.get("/", response_model=list[FlowReadWithStyle], status_code=200)
+@router.get("/", response_model=list[FlowRead], status_code=200)
 def read_flows(*, session: Session = Depends(get_session)):
    """Read all flows."""
    try:
@ -42,7 +41,7 @@ def read_flows(*, session: Session = Depends(get_session)):
    return [jsonable_encoder(flow) for flow in flows]


-@router.get("/{flow_id}", response_model=FlowReadWithStyle, status_code=200)
+@router.get("/{flow_id}", response_model=FlowRead, status_code=200)
 def read_flow(*, session: Session = Depends(get_session), flow_id: UUID):
    """Read a flow."""
    if flow := session.get(Flow, flow_id):
@ -61,7 +60,8 @@ def update_flow(
    if not db_flow:
        raise HTTPException(status_code=404, detail="Flow not found")
    flow_data = flow.dict(exclude_unset=True)
-    if settings.REMOVE_API_KEYS:
+    settings_manager = get_settings_manager()
+    if settings_manager.settings.REMOVE_API_KEYS:
        flow_data = remove_api_keys(flow_data)
    for key, value in flow_data.items():
        setattr(db_flow, key, value)
--- a/src/backend/langflow/api/v1/schemas.py
+++ b/src/backend/langflow/api/v1/schemas.py
@ -1,7 +1,7 @@
 from enum import Enum
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
-from langflow.database.models.flow import FlowCreate, FlowRead
+from langflow.services.database.models.flow import FlowCreate, FlowRead
 from pydantic import BaseModel, Field, validator
 import json

--- a/src/backend/langflow/auth/init.py
+++ b/src/backend/langflow/auth/init.py
--- a/src/backend/langflow/auth/auth.py
+++ b/src/backend/langflow/auth/auth.py
@ -0,0 +1,177 @@
+from uuid import UUID
+from typing import Annotated
+from jose import JWTError, jwt
+from sqlalchemy.orm import Session
+from passlib.context import CryptContext
+from fastapi.security import OAuth2PasswordBearer
+from fastapi import Depends, HTTPException, status
+from datetime import datetime, timedelta, timezone
+
+from langflow.services.utils import get_settings_manager
+
+from langflow.services.utils import get_session
+from langflow.database.models.user import (
+    User,
+    get_user_by_id,
+    get_user_by_username,
+    update_user_last_login_at,
+)
+
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="login")
+
+
+async def get_current_user(
+    token: Annotated[str, Depends(oauth2_scheme)], db: Session = Depends(get_session)
+) -> User:
+    settings_manager = get_settings_manager()
+
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+
+    try:
+        payload = jwt.decode(
+            token,
+            settings_manager.settings.SECRET_KEY,
+            algorithms=[settings_manager.settings.ALGORITHM],
+        )
+        user_id: UUID = payload.get("sub")  # type: ignore
+        token_type: str = payload.get("type")  # type: ignore
+
+        if user_id is None or token_type:
+            raise credentials_exception
+    except JWTError as e:
+        raise credentials_exception from e
+
+    user = get_user_by_id(db, user_id)  # type: ignore
+    if user is None:
+        raise credentials_exception
+    return user
+
+
+async def get_current_active_user(
+    current_user: Annotated[User, Depends(get_current_user)]
+):
+    if not current_user.is_active:
+        raise HTTPException(status_code=400, detail="Inactive user")
+    return current_user
+
+
+def verify_password(plain_password, hashed_password):
+    return pwd_context.verify(plain_password, hashed_password)
+
+
+def get_password_hash(password):
+    return pwd_context.hash(password)
+
+
+def create_token(data: dict, expires_delta: timedelta):
+    settings_manager = get_settings_manager()
+
+    to_encode = data.copy()
+    expire = datetime.now(timezone.utc) + expires_delta
+    to_encode["exp"] = expire
+
+    return jwt.encode(
+        to_encode,
+        settings_manager.settings.SECRET_KEY,
+        algorithm=settings_manager.settings.ALGORITHM,
+    )
+
+
+def create_user_longterm_token(
+    user_id: UUID, db: Session = Depends(get_session), update_last_login: bool = False
+) -> dict:
+    access_token_expires_longterm = timedelta(days=365)
+    access_token = create_token(
+        data={"sub": str(user_id)},
+        expires_delta=access_token_expires_longterm,
+    )
+
+    # Update: last_login_at
+    if update_last_login:
+        update_user_last_login_at(user_id, db)
+
+    return {
+        "access_token": access_token,
+        "refresh_token": None,
+        "token_type": "bearer",
+    }
+
+
+def create_user_tokens(
+    user_id: UUID, db: Session = Depends(get_session), update_last_login: bool = False
+) -> dict:
+    settings_manager = get_settings_manager()
+
+    access_token_expires = timedelta(
+        minutes=settings_manager.settings.ACCESS_TOKEN_EXPIRE_MINUTES
+    )
+    access_token = create_token(
+        data={"sub": str(user_id)},
+        expires_delta=access_token_expires,
+    )
+
+    refresh_token_expires = timedelta(
+        minutes=settings_manager.settings.REFRESH_TOKEN_EXPIRE_MINUTES
+    )
+    refresh_token = create_token(
+        data={"sub": str(user_id), "type": "rf"},
+        expires_delta=refresh_token_expires,
+    )
+
+    # Update: last_login_at
+    if update_last_login:
+        update_user_last_login_at(user_id, db)
+
+    return {
+        "access_token": access_token,
+        "refresh_token": refresh_token,
+        "token_type": "bearer",
+    }
+
+
+def create_refresh_token(refresh_token: str, db: Session = Depends(get_session)):
+    settings_manager = get_settings_manager()
+
+    try:
+        payload = jwt.decode(
+            refresh_token,
+            settings_manager.settings.SECRET_KEY,
+            algorithms=[settings_manager.settings.ALGORITHM],
+        )
+        user_id: UUID = payload.get("sub")  # type: ignore
+        token_type: str = payload.get("type")  # type: ignore
+
+        if user_id is None or token_type is None:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid refresh token"
+            )
+
+        return create_user_tokens(user_id, db)
+
+    except JWTError as e:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid refresh token",
+        ) from e
+
+
+def authenticate_user(
+    username: str, password: str, db: Session = Depends(get_session)
+) -> User | None:
+    user = get_user_by_username(db, username)
+
+    if not user:
+        return None
+
+    if not user.is_active:
+        if not user.last_login_at:
+            raise HTTPException(status_code=400, detail="Waiting for approval")
+        raise HTTPException(status_code=400, detail="Inactive user")
+
+    return user if verify_password(password, user.password) else None
--- a/src/backend/langflow/cache/init.py
+++ b/src/backend/langflow/cache/init.py
@ -1,7 +0,0 @@
-from langflow.cache.manager import cache_manager
-from langflow.cache.flow import InMemoryCache
-
-__all__ = [
-    "cache_manager",
-    "InMemoryCache",
-]
--- a/src/backend/langflow/components/chains/prompt_runner.py
+++ b/src/backend/langflow/components/chains/prompt_runner.py
--- a/src/backend/langflow/components/toolkits/Metaphor.py
+++ b/src/backend/langflow/components/toolkits/Metaphor.py
@ -0,0 +1,56 @@
+from typing import List, Union
+from langflow import CustomComponent
+
+from metaphor_python import Metaphor  # type: ignore
+from langchain.tools import Tool
+from langchain.agents import tool
+from langchain.agents.agent_toolkits.base import BaseToolkit
+
+
+class MetaphorToolkit(CustomComponent):
+    display_name: str = "Metaphor"
+    description: str = "Metaphor Toolkit"
+    documentation = (
+        "https://python.langchain.com/docs/integrations/tools/metaphor_search"
+    )
+    beta = True
+    # api key should be password = True
+    field_config = {
+        "metaphor_api_key": {"display_name": "Metaphor API Key", "password": True},
+        "code": {"advanced": True},
+    }
+
+    def build(
+        self,
+        metaphor_api_key: str,
+        use_autoprompt: bool = True,
+        search_num_results: int = 5,
+        similar_num_results: int = 5,
+    ) -> Union[Tool, BaseToolkit]:
+        # If documents, then we need to create a Vectara instance using .from_documents
+        client = Metaphor(api_key=metaphor_api_key)
+
+        @tool
+        def search(query: str):
+            """Call search engine with a query."""
+            return client.search(
+                query, use_autoprompt=use_autoprompt, num_results=search_num_results
+            )
+
+        @tool
+        def get_contents(ids: List[str]):
+            """Get contents of a webpage.
+
+            The ids passed in should be a list of ids as fetched from `search`.
+            """
+            return client.get_contents(ids)
+
+        @tool
+        def find_similar(url: str):
+            """Get search results similar to a given URL.
+
+            The url passed in should be a URL returned from `search`
+            """
+            return client.find_similar(url, num_results=similar_num_results)
+
+        return [search, get_contents, find_similar]  # type: ignore
--- a/src/backend/langflow/components/toolkits/init.py
+++ b/src/backend/langflow/components/toolkits/init.py
--- a/src/backend/langflow/components/vectorstores/Vectara.py
+++ b/src/backend/langflow/components/vectorstores/Vectara.py
@ -0,0 +1,50 @@
+from typing import Optional, Union
+from langflow import CustomComponent
+
+from langchain.vectorstores import Vectara
+from langchain.schema import Document
+from langchain.vectorstores.base import VectorStore
+from langchain.schema import BaseRetriever
+from langchain.embeddings.base import Embeddings
+
+
+class VectaraComponent(CustomComponent):
+    display_name: str = "Vectara"
+    description: str = "Implementation of Vector Store using Vectara"
+    documentation = (
+        "https://python.langchain.com/docs/integrations/vectorstores/vectara"
+    )
+    beta = True
+    # api key should be password = True
+    field_config = {
+        "vectara_customer_id": {"display_name": "Vectara Customer ID"},
+        "vectara_corpus_id": {"display_name": "Vectara Corpus ID"},
+        "vectara_api_key": {"display_name": "Vectara API Key", "password": True},
+        "code": {"show": False},
+        "documents": {"display_name": "Documents"},
+        "embedding": {"display_name": "Embedding"},
+    }
+
+    def build(
+        self,
+        vectara_customer_id: str,
+        vectara_corpus_id: str,
+        vectara_api_key: str,
+        embedding: Optional[Embeddings] = None,
+        documents: Optional[Document] = None,
+    ) -> Union[VectorStore, BaseRetriever]:
+        # If documents, then we need to create a Vectara instance using .from_documents
+        if documents is not None and embedding is not None:
+            return Vectara.from_documents(
+                documents=documents,  # type: ignore
+                vectara_customer_id=vectara_customer_id,
+                vectara_corpus_id=vectara_corpus_id,
+                vectara_api_key=vectara_api_key,
+                embedding=embedding,
+            )
+
+        return Vectara(
+            vectara_customer_id=vectara_customer_id,
+            vectara_corpus_id=vectara_corpus_id,
+            vectara_api_key=vectara_api_key,
+        )
--- a/src/backend/langflow/components/vectorstores/init.py
+++ b/src/backend/langflow/components/vectorstores/init.py
--- a/src/backend/langflow/config.yaml
+++ b/src/backend/langflow/config.yaml
@ -104,6 +104,8 @@ embeddings:
    documentation: "https://python.langchain.com/docs/modules/data_connection/text_embedding/integrations/sentence_transformers"
  CohereEmbeddings:
    documentation: "https://python.langchain.com/docs/modules/data_connection/text_embedding/integrations/cohere"
+  VertexAIEmbeddings:
+    documentation: "https://python.langchain.com/docs/modules/data_connection/text_embedding/integrations/google_vertex_ai_palm"
 llms:
  OpenAI:
    documentation: "https://python.langchain.com/docs/modules/model_io/models/llms/integrations/openai"
@ -127,8 +129,8 @@ llms:
  # There's a bug in this component deactivating until we get it sorted: _language_models.py", line 804, in send_message
  #     is_blocked=safety_attributes.get("blocked", False),
  # AttributeError: 'list' object has no attribute 'get'
-  # ChatVertexAI:
-  #   documentation: "https://python.langchain.com/docs/modules/model_io/models/chat/integrations/google_vertex_ai_palm"
+  ChatVertexAI:
+    documentation: "https://python.langchain.com/docs/modules/model_io/models/chat/integrations/google_vertex_ai_palm"
  ###
 memories:
  # https://github.com/supabase-community/supabase-py/issues/482
--- a/src/backend/langflow/database/base.py
+++ b/src/backend/langflow/database/base.py
@ -1,78 +0,0 @@
-from contextlib import contextmanager
-import os
-
-from sqlmodel import SQLModel, Session, create_engine
-from langflow.utils.logger import logger
-
-
-class Engine:
-    _instance = None
-
-    @classmethod
-    def get(cls):
-        logger.debug("Getting database engine")
-        if cls._instance is None:
-            cls.create()
-        return cls._instance
-
-    @classmethod
-    def create(cls):
-        logger.debug("Creating database engine")
-        from langflow.settings import settings
-
-        if langflow_database_url := os.getenv("LANGFLOW_DATABASE_URL"):
-            settings.DATABASE_URL = langflow_database_url
-            logger.debug("Using LANGFLOW_DATABASE_URL")
-
-        if settings.DATABASE_URL and settings.DATABASE_URL.startswith("sqlite"):
-            connect_args = {"check_same_thread": False}
-        else:
-            connect_args = {}
-        if not settings.DATABASE_URL:
-            raise RuntimeError("No database_url provided")
-        cls._instance = create_engine(settings.DATABASE_URL, connect_args=connect_args)
-
-    @classmethod
-    def update(cls):
-        logger.debug("Updating database engine")
-        cls._instance = None
-        cls.create()
-
-
-def create_db_and_tables():
-    logger.debug("Creating database and tables")
-    try:
-        SQLModel.metadata.create_all(Engine.get())
-    except Exception as exc:
-        logger.error(f"Error creating database and tables: {exc}")
-        raise RuntimeError("Error creating database and tables") from exc
-    # Now check if the table Flow exists, if not, something went wrong
-    # and we need to create the tables again.
-    from sqlalchemy import inspect
-
-    inspector = inspect(Engine.get())
-    if "flow" not in inspector.get_table_names():
-        logger.error("Something went wrong creating the database and tables.")
-        logger.error("Please check your database settings.")
-
-        raise RuntimeError("Something went wrong creating the database and tables.")
-    else:
-        logger.debug("Database and tables created successfully")
-
-
-@contextmanager
-def session_getter():
-    try:
-        session = Session(Engine.get())
-        yield session
-    except Exception as e:
-        print("Session rollback because of exception:", e)
-        session.rollback()
-        raise
-    finally:
-        session.close()
-
-
-def get_session():
-    with session_getter() as session:
-        yield session
--- a/src/backend/langflow/database/models/flow_style.py
+++ b/src/backend/langflow/database/models/flow_style.py
@ -1,33 +0,0 @@
-# Path: src/backend/langflow/database/models/flowstyle.py
-
-from langflow.database.models.base import SQLModelSerializable
-from sqlmodel import Field, Relationship
-from uuid import UUID, uuid4
-from typing import TYPE_CHECKING, Optional
-
-if TYPE_CHECKING:
-    from langflow.database.models.flow import Flow
-
-
-class FlowStyleBase(SQLModelSerializable):
-    color: str
-    emoji: str
-    flow_id: UUID = Field(default=None, foreign_key="flow.id")
-
-
-class FlowStyle(FlowStyleBase, table=True):
-    id: UUID = Field(default_factory=uuid4, primary_key=True, unique=True)
-    flow: "Flow" = Relationship(back_populates="style")
-
-
-class FlowStyleUpdate(SQLModelSerializable):
-    color: Optional[str] = None
-    emoji: Optional[str] = None
-
-
-class FlowStyleCreate(FlowStyleBase):
-    pass
-
-
-class FlowStyleRead(FlowStyleBase):
-    id: UUID
--- a/src/backend/langflow/database/models/token.py
+++ b/src/backend/langflow/database/models/token.py
@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+
+class Token(BaseModel):
+    access_token: str
+    refresh_token: str
+    token_type: str
--- a/src/backend/langflow/database/models/user.py
+++ b/src/backend/langflow/database/models/user.py
@ -0,0 +1,94 @@
+from sqlmodel import Field
+from uuid import UUID, uuid4
+from pydantic import BaseModel
+from typing import Optional, List
+from sqlalchemy.orm import Session
+from datetime import timezone, datetime
+from sqlalchemy.exc import IntegrityError
+from fastapi import HTTPException, Depends
+
+from langflow.services.utils import get_session
+from langflow.services.database.models.base import SQLModelSerializable, SQLModel
+
+
+class User(SQLModelSerializable, table=True):
+    id: UUID = Field(default_factory=uuid4, primary_key=True, unique=True)
+    username: str = Field(index=True, unique=True)
+    password: str = Field()
+    is_active: bool = Field(default=False)
+    is_superuser: bool = Field(default=False)
+    create_at: datetime = Field(default_factory=datetime.utcnow)
+    updated_at: datetime = Field(default_factory=datetime.utcnow)
+    last_login_at: Optional[datetime] = Field()
+
+
+class UserAddModel(SQLModel):
+    username: str = Field()
+    password: str = Field()
+
+
+class UserListModel(SQLModel):
+    id: UUID = Field(default_factory=uuid4)
+    username: str = Field()
+    is_active: bool = Field()
+    is_superuser: bool = Field()
+    create_at: datetime = Field()
+    updated_at: datetime = Field()
+    last_login_at: Optional[datetime] = Field()
+
+
+class UserPatchModel(SQLModel):
+    username: Optional[str] = Field()
+    is_active: Optional[bool] = Field()
+    is_superuser: Optional[bool] = Field()
+    last_login_at: Optional[datetime] = Field()
+
+
+class UsersResponse(BaseModel):
+    total_count: int
+    users: List[UserListModel]
+
+
+def get_user_by_username(db: Session, username: str) -> User:
+    db_user = db.query(User).filter(User.username == username).first()
+    return User.from_orm(db_user) if db_user else None  # type: ignore
+
+
+def get_user_by_id(db: Session, id: UUID) -> User:
+    db_user = db.query(User).filter(User.id == id).first()
+    return User.from_orm(db_user) if db_user else None  # type: ignore
+
+
+def update_user(
+    user_id: UUID, user: UserPatchModel, db: Session = Depends(get_session)
+) -> User:
+    user_db = get_user_by_username(db, user.username)  # type: ignore
+    if user_db and user_db.id != user_id:
+        raise HTTPException(status_code=409, detail="Username already exists")
+
+    user_db = get_user_by_id(db, user_id)
+    if not user_db:
+        raise HTTPException(status_code=404, detail="User not found")
+
+    try:
+        user_data = user.dict(exclude_unset=True)
+        for key, value in user_data.items():
+            setattr(user_db, key, value)
+
+        user_db.updated_at = datetime.now(timezone.utc)
+        user_db = db.merge(user_db)
+        db.commit()
+        if db.identity_key(instance=user_db) is not None:
+            db.refresh(user_db)
+
+    except IntegrityError as e:
+        db.rollback()
+        raise HTTPException(status_code=400, detail=str(e)) from e
+
+    return user_db
+
+
+def update_user_last_login_at(user_id: UUID, db: Session = Depends(get_session)):
+    user_data = UserPatchModel(last_login_at=datetime.now(timezone.utc))  # type: ignore
+
+    return update_user(user_id, user_data, db)
--- a/src/backend/langflow/graph/graph/base.py
+++ b/src/backend/langflow/graph/graph/base.py
@ -1,7 +1,7 @@
 from typing import Dict, Generator, List, Type, Union

 from langflow.graph.edge.base import Edge
-from langflow.graph.graph.constants import VERTEX_TYPE_MAP
+from langflow.graph.graph.constants import lazy_load_vertex_dict
 from langflow.graph.vertex.base import Vertex
 from langflow.graph.vertex.types import (
    FileToolVertex,
@ -187,10 +187,12 @@ class Graph:
        """Returns the node class based on the node type."""
        if node_type in FILE_TOOLS:
            return FileToolVertex
-        if node_type in VERTEX_TYPE_MAP:
-            return VERTEX_TYPE_MAP[node_type]
+        if node_type in lazy_load_vertex_dict.VERTEX_TYPE_MAP:
+            return lazy_load_vertex_dict.VERTEX_TYPE_MAP[node_type]
        return (
-            VERTEX_TYPE_MAP[node_lc_type] if node_lc_type in VERTEX_TYPE_MAP else Vertex
+            lazy_load_vertex_dict.VERTEX_TYPE_MAP[node_lc_type]
+            if node_lc_type in lazy_load_vertex_dict.VERTEX_TYPE_MAP
+            else Vertex
        )

    def _build_vertices(self) -> List[Vertex]:
--- a/src/backend/langflow/graph/graph/constants.py
+++ b/src/backend/langflow/graph/graph/constants.py
@ -1,4 +1,3 @@
-from langflow.graph.vertex.base import Vertex
 from langflow.graph.vertex import types
 from langflow.interface.agents.base import agent_creator
 from langflow.interface.chains.base import chain_creator
@ -15,23 +14,45 @@ from langflow.interface.wrappers.base import wrapper_creator
 from langflow.interface.output_parsers.base import output_parser_creator
 from langflow.interface.retrievers.base import retriever_creator
 from langflow.interface.custom.base import custom_component_creator
-from typing import Dict, Type
+from langflow.utils.lazy_load import LazyLoadDictBase


-VERTEX_TYPE_MAP: Dict[str, Type[Vertex]] = {
-    **{t: types.PromptVertex for t in prompt_creator.to_list()},
-    **{t: types.AgentVertex for t in agent_creator.to_list()},
-    **{t: types.ChainVertex for t in chain_creator.to_list()},
-    **{t: types.ToolVertex for t in tool_creator.to_list()},
-    **{t: types.ToolkitVertex for t in toolkits_creator.to_list()},
-    **{t: types.WrapperVertex for t in wrapper_creator.to_list()},
-    **{t: types.LLMVertex for t in llm_creator.to_list()},
-    **{t: types.MemoryVertex for t in memory_creator.to_list()},
-    **{t: types.EmbeddingVertex for t in embedding_creator.to_list()},
-    **{t: types.VectorStoreVertex for t in vectorstore_creator.to_list()},
-    **{t: types.DocumentLoaderVertex for t in documentloader_creator.to_list()},
-    **{t: types.TextSplitterVertex for t in textsplitter_creator.to_list()},
-    **{t: types.OutputParserVertex for t in output_parser_creator.to_list()},
-    **{t: types.CustomComponentVertex for t in custom_component_creator.to_list()},
-    **{t: types.RetrieverVertex for t in retriever_creator.to_list()},
-}
+class VertexTypesDict(LazyLoadDictBase):
+    def __init__(self):
+        self._all_types_dict = None
+
+    @property
+    def VERTEX_TYPE_MAP(self):
+        return self.all_types_dict
+
+    def _build_dict(self):
+        langchain_types_dict = self.get_type_dict()
+        return {
+            **langchain_types_dict,
+            "Custom": ["Custom Tool", "Python Function"],
+        }
+
+    def get_type_dict(self):
+        return {
+            **{t: types.PromptVertex for t in prompt_creator.to_list()},
+            **{t: types.AgentVertex for t in agent_creator.to_list()},
+            **{t: types.ChainVertex for t in chain_creator.to_list()},
+            **{t: types.ToolVertex for t in tool_creator.to_list()},
+            **{t: types.ToolkitVertex for t in toolkits_creator.to_list()},
+            **{t: types.WrapperVertex for t in wrapper_creator.to_list()},
+            **{t: types.LLMVertex for t in llm_creator.to_list()},
+            **{t: types.MemoryVertex for t in memory_creator.to_list()},
+            **{t: types.EmbeddingVertex for t in embedding_creator.to_list()},
+            **{t: types.VectorStoreVertex for t in vectorstore_creator.to_list()},
+            **{t: types.DocumentLoaderVertex for t in documentloader_creator.to_list()},
+            **{t: types.TextSplitterVertex for t in textsplitter_creator.to_list()},
+            **{t: types.OutputParserVertex for t in output_parser_creator.to_list()},
+            **{
+                t: types.CustomComponentVertex
+                for t in custom_component_creator.to_list()
+            },
+            **{t: types.RetrieverVertex for t in retriever_creator.to_list()},
+        }
+
+
+lazy_load_vertex_dict = VertexTypesDict()
--- a/src/backend/langflow/graph/vertex/base.py
+++ b/src/backend/langflow/graph/vertex/base.py
@ -1,6 +1,6 @@
 import ast
 from langflow.interface.initialize import loading
-from langflow.interface.listing import ALL_TYPES_DICT
+from langflow.interface.listing import lazy_load_dict
 from langflow.utils.constants import DIRECT_TYPES
 from langflow.utils.logger import logger
 from langflow.utils.util import sync_to_async
@ -62,7 +62,7 @@ class Vertex:
        )

        if self.base_type is None:
-            for base_type, value in ALL_TYPES_DICT.items():
+            for base_type, value in lazy_load_dict.ALL_TYPES_DICT.items():
                if self.vertex_type in value:
                    self.base_type = base_type
                    break
--- a/src/backend/langflow/interface/agents/base.py
+++ b/src/backend/langflow/interface/agents/base.py
@ -5,7 +5,8 @@ from langchain.agents import types
 from langflow.custom.customs import get_custom_nodes
 from langflow.interface.agents.custom import CUSTOM_AGENTS
 from langflow.interface.base import LangChainTypeCreator
-from langflow.settings import settings
+from langflow.services.utils import get_settings_manager
+
 from langflow.template.frontend_node.agents import AgentFrontendNode
 from langflow.utils.logger import logger
 from langflow.utils.util import build_template_from_class, build_template_from_method
@ -53,13 +54,17 @@ class AgentCreator(LangChainTypeCreator):
    # Now this is a generator
    def to_list(self) -> List[str]:
        names = []
+        settings_manager = get_settings_manager()
        for _, agent in self.type_to_loader_dict.items():
            agent_name = (
                agent.function_name()
                if hasattr(agent, "function_name")
                else agent.__name__
            )
-            if agent_name in settings.AGENTS or settings.DEV:
+            if (
+                agent_name in settings_manager.settings.AGENTS
+                or settings_manager.settings.DEV
+            ):
                names.append(agent_name)
        return names

--- a/src/backend/langflow/interface/base.py
+++ b/src/backend/langflow/interface/base.py
@ -2,13 +2,14 @@ from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional, Type, Union
 from langchain.chains.base import Chain
 from langchain.agents import AgentExecutor
+from langflow.services.utils import get_settings_manager
 from pydantic import BaseModel

 from langflow.template.field.base import TemplateField
 from langflow.template.frontend_node.base import FrontendNode
 from langflow.template.template.base import Template
 from langflow.utils.logger import logger
-from langflow.settings import settings
+

 # Assuming necessary imports for Field, Template, and FrontendNode classes

@ -26,9 +27,12 @@ class LangChainTypeCreator(BaseModel, ABC):
    @property
    def docs_map(self) -> Dict[str, str]:
        """A dict with the name of the component as key and the documentation link as value."""
+        settings_manager = get_settings_manager()
        if self.name_docs_dict is None:
            try:
-                type_settings = getattr(settings, self.type_name.upper())
+                type_settings = getattr(
+                    settings_manager.settings, self.type_name.upper()
+                )
                self.name_docs_dict = {
                    name: value_dict["documentation"]
                    for name, value_dict in type_settings.items()
--- a/src/backend/langflow/interface/chains/base.py
+++ b/src/backend/langflow/interface/chains/base.py
@ -3,7 +3,8 @@ from typing import Any, Dict, List, Optional, Type
 from langflow.custom.customs import get_custom_nodes
 from langflow.interface.base import LangChainTypeCreator
 from langflow.interface.importing.utils import import_class
-from langflow.settings import settings
+from langflow.services.utils import get_settings_manager
+
 from langflow.template.frontend_node.chains import ChainFrontendNode
 from langflow.utils.logger import logger
 from langflow.utils.util import build_template_from_class, build_template_from_method
@ -30,6 +31,7 @@ class ChainCreator(LangChainTypeCreator):
    @property
    def type_to_loader_dict(self) -> Dict:
        if self.type_dict is None:
+            settings_manager = get_settings_manager()
            self.type_dict: dict[str, Any] = {
                chain_name: import_class(f"langchain.chains.{chain_name}")
                for chain_name in chains.__all__
@ -43,7 +45,8 @@ class ChainCreator(LangChainTypeCreator):
            self.type_dict = {
                name: chain
                for name, chain in self.type_dict.items()
-                if name in settings.CHAINS or settings.DEV
+                if name in settings_manager.settings.CHAINS
+                or settings_manager.settings.DEV
            }
        return self.type_dict

--- a/src/backend/langflow/interface/custom/component.py
+++ b/src/backend/langflow/interface/custom/component.py
@ -66,6 +66,9 @@ class Component(BaseModel):
                elif "beta" in item_name:
                    template_config["beta"] = ast.literal_eval(item_value)

+                elif "documentation" in item_name:
+                    template_config["documentation"] = ast.literal_eval(item_value)
+
        return template_config

    def build(self, *args: Any, **kwargs: Any) -> Any:
--- a/src/backend/langflow/interface/custom/custom_component.py
+++ b/src/backend/langflow/interface/custom/custom_component.py
@ -3,11 +3,12 @@ from fastapi import HTTPException
 from langflow.interface.custom.constants import CUSTOM_COMPONENT_SUPPORTED_TYPES
 from langflow.interface.custom.component import Component
 from langflow.interface.custom.directory_reader import DirectoryReader
+from langflow.services.utils import get_db_manager

 from langflow.utils import validate

-from langflow.database.base import session_getter
-from langflow.database.models.flow import Flow
+from langflow.services.database.utils import session_getter
+from langflow.services.database.models.flow import Flow
 from pydantic import Extra
 import yaml

@ -49,7 +50,9 @@ class CustomComponent(Component, extra=Extra.allow):
        reader = DirectoryReader("", False)

        for type_hint in TYPE_HINT_LIST:
-            if reader.is_type_hint_used_but_not_imported(type_hint, code):
+            if reader._is_type_hint_used_in_args(
+                "Optional", code
+            ) and not reader._is_type_hint_imported("Optional", code):
                error_detail = {
                    "error": "Type hint Error",
                    "traceback": f"Type hint '{type_hint}' is used but not imported in the code.",
@ -92,9 +95,9 @@ class CustomComponent(Component, extra=Extra.allow):
        return build_method["args"]

    @property
-    def get_function_entrypoint_return_type(self) -> str:
+    def get_function_entrypoint_return_type(self) -> List[str]:
        if not self.code:
-            return ""
+            return []
        tree = self.get_code_tree(self.code)

        component_classes = [
@ -103,7 +106,7 @@ class CustomComponent(Component, extra=Extra.allow):
            if self.code_class_base_inheritance in cls["bases"]
        ]
        if not component_classes:
-            return ""
+            return []

        # Assume the first Component class is the one we're interested in
        component_class = component_classes[0]
@ -114,11 +117,21 @@ class CustomComponent(Component, extra=Extra.allow):
        ]

        if not build_methods:
-            return ""
+            return []

        build_method = build_methods[0]
+        return_type = build_method["return_type"]
+        if not return_type:
+            return []
+        # If the return type is not a Union, then we just return it as a list
+        if "Union" not in return_type:
+            return [return_type] if return_type in self.return_type_valid_list else []

-        return build_method["return_type"]
+        # If the return type is a Union, then we need to parse it
+        return_type = return_type.replace("Union", "").replace("[", "").replace("]", "")
+        return_type = return_type.split(",")
+        return_type = [item.strip() for item in return_type]
+        return [item for item in return_type if item in self.return_type_valid_list]

    @property
    def get_main_class_name(self):
@ -159,7 +172,8 @@ class CustomComponent(Component, extra=Extra.allow):
        from langflow.processing.process import build_sorted_vertices_with_caching
        from langflow.processing.process import process_tweaks

-        with session_getter() as session:
+        db_manager = get_db_manager()
+        with session_getter(db_manager) as session:
            graph_data = flow.data if (flow := session.get(Flow, flow_id)) else None
        if not graph_data:
            raise ValueError(f"Flow {flow_id} not found")
@ -169,7 +183,8 @@ class CustomComponent(Component, extra=Extra.allow):

    def list_flows(self, *, get_session: Optional[Callable] = None) -> List[Flow]:
        get_session = get_session or session_getter
-        with get_session() as session:
+        db_manager = get_db_manager()
+        with get_session(db_manager) as session:
            flows = session.query(Flow).all()
        return flows

@ -182,8 +197,8 @@ class CustomComponent(Component, extra=Extra.allow):
        get_session: Optional[Callable] = None,
    ) -> Flow:
        get_session = get_session or session_getter
-
-        with get_session() as session:
+        db_manager = get_db_manager()
+        with get_session(db_manager) as session:
            if flow_id:
                flow = session.query(Flow).get(flow_id)
            elif flow_name:
--- a/src/backend/langflow/interface/custom/directory_reader.py
+++ b/src/backend/langflow/interface/custom/directory_reader.py
@ -152,15 +152,19 @@ class DirectoryReader:
        Check if a specific type hint is used in the
        function definitions within the given code.
        """
-        module = ast.parse(code)
+        try:
+            module = ast.parse(code)

-        for node in ast.walk(module):
-            if isinstance(node, ast.FunctionDef):
-                for arg in node.args.args:
-                    if self._is_type_hint_in_arg_annotation(
-                        arg.annotation, type_hint_name
-                    ):
-                        return True
+            for node in ast.walk(module):
+                if isinstance(node, ast.FunctionDef):
+                    for arg in node.args.args:
+                        if self._is_type_hint_in_arg_annotation(
+                            arg.annotation, type_hint_name
+                        ):
+                            return True
+        except SyntaxError:
+            # Returns False if the code is not valid Python
+            return False
        return False

    def _is_type_hint_in_arg_annotation(self, annotation, type_hint_name: str) -> bool:
@ -204,8 +208,13 @@ class DirectoryReader:
            return False, "Syntax error"
        elif not self.validate_build(file_content):
            return False, "Missing build function"
-        elif self.is_type_hint_used_but_not_imported("Optional", file_content):
-            return False, "Type hint 'Optional' is used but not imported in the code."
+        elif self._is_type_hint_used_in_args(
+            "Optional", file_content
+        ) and not self._is_type_hint_imported("Optional", file_content):
+            return (
+                False,
+                "Type hint 'Optional' is used but not imported in the code.",
+            )
        else:
            if self.compress_code_field:
                file_content = str(StringCompressor(file_content).compress_string())
--- a/src/backend/langflow/interface/document_loaders/base.py
+++ b/src/backend/langflow/interface/document_loaders/base.py
@ -1,9 +1,10 @@
 from typing import Dict, List, Optional, Type

 from langflow.interface.base import LangChainTypeCreator
+from langflow.services.utils import get_settings_manager
 from langflow.template.frontend_node.documentloaders import DocumentLoaderFrontNode
 from langflow.interface.custom_lists import documentloaders_type_to_cls_dict
-from langflow.settings import settings
+
 from langflow.utils.logger import logger
 from langflow.utils.util import build_template_from_class

@ -30,10 +31,12 @@ class DocumentLoaderCreator(LangChainTypeCreator):
            return None

    def to_list(self) -> List[str]:
+        settings_manager = get_settings_manager()
        return [
            documentloader.__name__
            for documentloader in self.type_to_loader_dict.values()
-            if documentloader.__name__ in settings.DOCUMENTLOADERS or settings.DEV
+            if documentloader.__name__ in settings_manager.settings.DOCUMENTLOADERS
+            or settings_manager.settings.DEV
        ]


--- a/src/backend/langflow/interface/embeddings/base.py
+++ b/src/backend/langflow/interface/embeddings/base.py
@ -2,7 +2,8 @@ from typing import Dict, List, Optional, Type

 from langflow.interface.base import LangChainTypeCreator
 from langflow.interface.custom_lists import embedding_type_to_cls_dict
-from langflow.settings import settings
+from langflow.services.utils import get_settings_manager
+
 from langflow.template.frontend_node.base import FrontendNode
 from langflow.template.frontend_node.embeddings import EmbeddingFrontendNode
 from langflow.utils.logger import logger
@ -32,10 +33,12 @@ class EmbeddingCreator(LangChainTypeCreator):
            return None

    def to_list(self) -> List[str]:
+        settings_manager = get_settings_manager()
        return [
            embedding.__name__
            for embedding in self.type_to_loader_dict.values()
-            if embedding.__name__ in settings.EMBEDDINGS or settings.DEV
+            if embedding.__name__ in settings_manager.settings.EMBEDDINGS
+            or settings_manager.settings.DEV
        ]


--- a/src/backend/langflow/interface/initialize/loading.py
+++ b/src/backend/langflow/interface/initialize/loading.py
@ -88,7 +88,7 @@ def instantiate_based_on_type(class_object, base_type, node_type, params):
    elif base_type == "toolkits":
        return instantiate_toolkit(node_type, class_object, params)
    elif base_type == "embeddings":
-        return instantiate_embedding(class_object, params)
+        return instantiate_embedding(node_type, class_object, params)
    elif base_type == "vectorstores":
        return instantiate_vectorstore(class_object, params)
    elif base_type == "documentloaders":
@ -116,9 +116,12 @@ def instantiate_based_on_type(class_object, base_type, node_type, params):


 def instantiate_custom_component(node_type, class_object, params):
-    class_object = get_function_custom(params.pop("code"))
+    # we need to make a copy of the params because we will be
+    # modifying it
+    params_copy = params.copy()
+    class_object = get_function_custom(params_copy.pop("code"))
    custom_component = class_object()
-    built_object = custom_component.build(**params)
+    built_object = custom_component.build(**params_copy)
    return built_object, {"repr": custom_component.custom_repr()}


@ -144,7 +147,7 @@ def instantiate_llm(node_type, class_object, params: Dict):
    # This is a workaround so JinaChat works until streaming is implemented
    # if "openai_api_base" in params and "jina" in params["openai_api_base"]:
    # False if condition is True
-    if node_type == "VertexAI":
+    if "VertexAI" in node_type:
        return initialize_vertexai(class_object=class_object, params=params)
    # max_tokens sometimes is a string and should be an int
    if "max_tokens" in params:
@ -258,9 +261,13 @@ def instantiate_toolkit(node_type, class_object: Type[BaseToolkit], params: Dict
    return loaded_toolkit


-def instantiate_embedding(class_object, params: Dict):
+def instantiate_embedding(node_type, class_object, params: Dict):
    params.pop("model", None)
    params.pop("headers", None)
+
+    if "VertexAI" in node_type:
+        return initialize_vertexai(class_object=class_object, params=params)
+
    try:
        return class_object(**params)
    except ValidationError:
--- a/src/backend/langflow/interface/initialize/vector_store.py
+++ b/src/backend/langflow/interface/initialize/vector_store.py
@ -130,8 +130,8 @@ def initialize_pinecone(class_object: Type[Pinecone], params: dict):

    import pinecone  # type: ignore

-    pinecone_api_key = params.get("pinecone_api_key")
-    pinecone_env = params.get("pinecone_env")
+    pinecone_api_key = params.pop("pinecone_api_key")
+    pinecone_env = params.pop("pinecone_env")

    if pinecone_api_key is None or pinecone_env is None:
        if os.getenv("PINECONE_API_KEY") is not None:
@ -171,11 +171,7 @@ def initialize_pinecone(class_object: Type[Pinecone], params: dict):
 def initialize_chroma(class_object: Type[Chroma], params: dict):
    """Initialize a ChromaDB object from the params"""
    if (  # type: ignore
-        "chroma_server_host" in params
-        or "chroma_server_http_port" in params
-        or "chroma_server_ssl_enabled" in params
-        or "chroma_server_grpc_port" in params
-        or "chroma_server_cors_allow_origins" in params
+        "chroma_server_host" in params or "chroma_server_http_port" in params
    ):
        import chromadb  # type: ignore

@ -186,6 +182,14 @@ def initialize_chroma(class_object: Type[Chroma], params: dict):
        }
        chroma_settings = chromadb.config.Settings(**settings_params)
        params["client_settings"] = chroma_settings
+    else:
+        # remove all chroma_server_ keys from params
+        params = {
+            key: value
+            for key, value in params.items()
+            if not key.startswith("chroma_server_")
+        }
+
    persist = params.pop("persist", False)
    if not docs_in_params(params):
        params.pop("documents", None)
--- a/src/backend/langflow/interface/listing.py
+++ b/src/backend/langflow/interface/listing.py
@ -14,34 +14,43 @@ from langflow.interface.wrappers.base import wrapper_creator
 from langflow.interface.output_parsers.base import output_parser_creator
 from langflow.interface.retrievers.base import retriever_creator
 from langflow.interface.custom.base import custom_component_creator
+from langflow.utils.lazy_load import LazyLoadDictBase


-def get_type_dict():
-    return {
-        "agents": agent_creator.to_list(),
-        "prompts": prompt_creator.to_list(),
-        "llms": llm_creator.to_list(),
-        "tools": tool_creator.to_list(),
-        "chains": chain_creator.to_list(),
-        "memory": memory_creator.to_list(),
-        "toolkits": toolkits_creator.to_list(),
-        "wrappers": wrapper_creator.to_list(),
-        "documentLoaders": documentloader_creator.to_list(),
-        "vectorStore": vectorstore_creator.to_list(),
-        "embeddings": embedding_creator.to_list(),
-        "textSplitters": textsplitter_creator.to_list(),
-        "utilities": utility_creator.to_list(),
-        "outputParsers": output_parser_creator.to_list(),
-        "retrievers": retriever_creator.to_list(),
-        "custom_components": custom_component_creator.to_list(),
-    }
+class AllTypesDict(LazyLoadDictBase):
+    def __init__(self):
+        self._all_types_dict = None
+
+    @property
+    def ALL_TYPES_DICT(self):
+        return self.all_types_dict
+
+    def _build_dict(self):
+        langchain_types_dict = self.get_type_dict()
+        return {
+            **langchain_types_dict,
+            "Custom": ["Custom Tool", "Python Function"],
+        }
+
+    def get_type_dict(self):
+        return {
+            "agents": agent_creator.to_list(),
+            "prompts": prompt_creator.to_list(),
+            "llms": llm_creator.to_list(),
+            "tools": tool_creator.to_list(),
+            "chains": chain_creator.to_list(),
+            "memory": memory_creator.to_list(),
+            "toolkits": toolkits_creator.to_list(),
+            "wrappers": wrapper_creator.to_list(),
+            "documentLoaders": documentloader_creator.to_list(),
+            "vectorStore": vectorstore_creator.to_list(),
+            "embeddings": embedding_creator.to_list(),
+            "textSplitters": textsplitter_creator.to_list(),
+            "utilities": utility_creator.to_list(),
+            "outputParsers": output_parser_creator.to_list(),
+            "retrievers": retriever_creator.to_list(),
+            "custom_components": custom_component_creator.to_list(),
+        }


-LANGCHAIN_TYPES_DICT = get_type_dict()
-
-# Now we'll build a dict with Langchain types and ours
-
-ALL_TYPES_DICT = {
-    **LANGCHAIN_TYPES_DICT,
-    "Custom": ["Custom Tool", "Python Function"],
-}
+lazy_load_dict = AllTypesDict()
--- a/src/backend/langflow/interface/llms/base.py
+++ b/src/backend/langflow/interface/llms/base.py
@ -2,7 +2,8 @@ from typing import Dict, List, Optional, Type

 from langflow.interface.base import LangChainTypeCreator
 from langflow.interface.custom_lists import llm_type_to_cls_dict
-from langflow.settings import settings
+from langflow.services.utils import get_settings_manager
+
 from langflow.template.frontend_node.llms import LLMFrontendNode
 from langflow.utils.logger import logger
 from langflow.utils.util import build_template_from_class
@ -33,10 +34,12 @@ class LLMCreator(LangChainTypeCreator):
            return None

    def to_list(self) -> List[str]:
+        settings_manager = get_settings_manager()
        return [
            llm.__name__
            for llm in self.type_to_loader_dict.values()
-            if llm.__name__ in settings.LLMS or settings.DEV
+            if llm.__name__ in settings_manager.settings.LLMS
+            or settings_manager.settings.DEV
        ]


--- a/src/backend/langflow/interface/memories/base.py
+++ b/src/backend/langflow/interface/memories/base.py
@ -2,7 +2,8 @@ from typing import Dict, List, Optional, Type

 from langflow.interface.base import LangChainTypeCreator
 from langflow.interface.custom_lists import memory_type_to_cls_dict
-from langflow.settings import settings
+from langflow.services.utils import get_settings_manager
+
 from langflow.template.frontend_node.base import FrontendNode
 from langflow.template.frontend_node.memories import MemoryFrontendNode
 from langflow.utils.logger import logger
@ -48,10 +49,12 @@ class MemoryCreator(LangChainTypeCreator):
            return None

    def to_list(self) -> List[str]:
+        settings_manager = get_settings_manager()
        return [
            memory.__name__
            for memory in self.type_to_loader_dict.values()
-            if memory.__name__ in settings.MEMORIES or settings.DEV
+            if memory.__name__ in settings_manager.settings.MEMORIES
+            or settings_manager.settings.DEV
        ]


--- a/src/backend/langflow/interface/output_parsers/base.py
+++ b/src/backend/langflow/interface/output_parsers/base.py
@ -4,7 +4,8 @@ from langchain import output_parsers

 from langflow.interface.base import LangChainTypeCreator
 from langflow.interface.importing.utils import import_class
-from langflow.settings import settings
+from langflow.services.utils import get_settings_manager
+
 from langflow.template.frontend_node.output_parsers import OutputParserFrontendNode
 from langflow.utils.logger import logger
 from langflow.utils.util import build_template_from_class, build_template_from_method
@ -23,6 +24,7 @@ class OutputParserCreator(LangChainTypeCreator):
    @property
    def type_to_loader_dict(self) -> Dict:
        if self.type_dict is None:
+            settings_manager = get_settings_manager()
            self.type_dict = {
                output_parser_name: import_class(
                    f"langchain.output_parsers.{output_parser_name}"
@ -33,7 +35,8 @@ class OutputParserCreator(LangChainTypeCreator):
            self.type_dict = {
                name: output_parser
                for name, output_parser in self.type_dict.items()
-                if name in settings.OUTPUT_PARSERS or settings.DEV
+                if name in settings_manager.settings.OUTPUT_PARSERS
+                or settings_manager.settings.DEV
            }
        return self.type_dict

--- a/src/backend/langflow/interface/prompts/base.py
+++ b/src/backend/langflow/interface/prompts/base.py
@ -5,7 +5,8 @@ from langchain import prompts
 from langflow.custom.customs import get_custom_nodes
 from langflow.interface.base import LangChainTypeCreator
 from langflow.interface.importing.utils import import_class
-from langflow.settings import settings
+from langflow.services.utils import get_settings_manager
+
 from langflow.template.frontend_node.prompts import PromptFrontendNode
 from langflow.utils.logger import logger
 from langflow.utils.util import build_template_from_class
@ -20,6 +21,7 @@ class PromptCreator(LangChainTypeCreator):

    @property
    def type_to_loader_dict(self) -> Dict:
+        settings_manager = get_settings_manager()
        if self.type_dict is None:
            self.type_dict = {
                prompt_name: import_class(f"langchain.prompts.{prompt_name}")
@ -34,7 +36,8 @@ class PromptCreator(LangChainTypeCreator):
            self.type_dict = {
                name: prompt
                for name, prompt in self.type_dict.items()
-                if name in settings.PROMPTS or settings.DEV
+                if name in settings_manager.settings.PROMPTS
+                or settings_manager.settings.DEV
            }
        return self.type_dict

--- a/src/backend/langflow/interface/retrievers/base.py
+++ b/src/backend/langflow/interface/retrievers/base.py
@ -4,7 +4,8 @@ from langchain import retrievers

 from langflow.interface.base import LangChainTypeCreator
 from langflow.interface.importing.utils import import_class
-from langflow.settings import settings
+from langflow.services.utils import get_settings_manager
+
 from langflow.template.frontend_node.retrievers import RetrieverFrontendNode
 from langflow.utils.logger import logger
 from langflow.utils.util import build_template_from_method, build_template_from_class
@ -48,10 +49,12 @@ class RetrieverCreator(LangChainTypeCreator):
            return None

    def to_list(self) -> List[str]:
+        settings_manager = get_settings_manager()
        return [
            retriever
            for retriever in self.type_to_loader_dict.keys()
-            if retriever in settings.RETRIEVERS or settings.DEV
+            if retriever in settings_manager.settings.RETRIEVERS
+            or settings_manager.settings.DEV
        ]


--- a/src/backend/langflow/interface/run.py
+++ b/src/backend/langflow/interface/run.py
@ -1,4 +1,4 @@
-from langflow.cache.utils import memoize_dict
+from langflow.services.cache.utils import memoize_dict
 from langflow.graph import Graph
 from langflow.utils.logger import logger

--- a/src/backend/langflow/interface/text_splitters/base.py
+++ b/src/backend/langflow/interface/text_splitters/base.py
@ -1,9 +1,10 @@
 from typing import Dict, List, Optional, Type

 from langflow.interface.base import LangChainTypeCreator
+from langflow.services.utils import get_settings_manager
 from langflow.template.frontend_node.textsplitters import TextSplittersFrontendNode
 from langflow.interface.custom_lists import textsplitter_type_to_cls_dict
-from langflow.settings import settings
+
 from langflow.utils.logger import logger
 from langflow.utils.util import build_template_from_class

@ -30,10 +31,12 @@ class TextSplitterCreator(LangChainTypeCreator):
            return None

    def to_list(self) -> List[str]:
+        settings_manager = get_settings_manager()
        return [
            textsplitter.__name__
            for textsplitter in self.type_to_loader_dict.values()
-            if textsplitter.__name__ in settings.TEXTSPLITTERS or settings.DEV
+            if textsplitter.__name__ in settings_manager.settings.TEXTSPLITTERS
+            or settings_manager.settings.DEV
        ]


--- a/src/backend/langflow/interface/toolkits/base.py
+++ b/src/backend/langflow/interface/toolkits/base.py
@ -4,7 +4,8 @@ from langchain.agents import agent_toolkits

 from langflow.interface.base import LangChainTypeCreator
 from langflow.interface.importing.utils import import_class, import_module
-from langflow.settings import settings
+from langflow.services.utils import get_settings_manager
+
 from langflow.utils.logger import logger
 from langflow.utils.util import build_template_from_class

@ -29,13 +30,15 @@ class ToolkitCreator(LangChainTypeCreator):
    @property
    def type_to_loader_dict(self) -> Dict:
        if self.type_dict is None:
+            settings_manager = get_settings_manager()
            self.type_dict = {
                toolkit_name: import_class(
                    f"langchain.agents.agent_toolkits.{toolkit_name}"
                )
                # if toolkit_name is not lower case it is a class
                for toolkit_name in agent_toolkits.__all__
-                if not toolkit_name.islower() and toolkit_name in settings.TOOLKITS
+                if not toolkit_name.islower()
+                and toolkit_name in settings_manager.settings.TOOLKITS
            }

        return self.type_dict
--- a/src/backend/langflow/interface/tools/base.py
+++ b/src/backend/langflow/interface/tools/base.py
@ -15,7 +15,8 @@ from langflow.interface.tools.constants import (
    OTHER_TOOLS,
 )
 from langflow.interface.tools.util import get_tool_params
-from langflow.settings import settings
+from langflow.services.utils import get_settings_manager
+
 from langflow.template.field.base import TemplateField
 from langflow.template.template.base import Template
 from langflow.utils import util
@ -66,6 +67,7 @@ class ToolCreator(LangChainTypeCreator):

    @property
    def type_to_loader_dict(self) -> Dict:
+        settings_manager = get_settings_manager()
        if self.tools_dict is None:
            all_tools = {}

@ -74,7 +76,10 @@ class ToolCreator(LangChainTypeCreator):

                tool_name = tool_params.get("name") or tool

-                if tool_name in settings.TOOLS or settings.DEV:
+                if (
+                    tool_name in settings_manager.settings.TOOLS
+                    or settings_manager.settings.DEV
+                ):
                    if tool_name == "JsonSpec":
                        tool_params["path"] = tool_params.pop("dict_")  # type: ignore
                    all_tools[tool_name] = {
--- a/src/backend/langflow/interface/types.py
+++ b/src/backend/langflow/interface/types.py
@ -1,6 +1,6 @@
 import ast
 import contextlib
-from typing import Any
+from typing import Any, List
 from langflow.api.utils import merge_nested_dicts_with_renaming
 from langflow.interface.agents.base import agent_creator
 from langflow.interface.chains.base import chain_creator
@ -199,6 +199,9 @@ def update_attributes(frontend_node, template_config):
    if "beta" in template_config:
        frontend_node["beta"] = template_config["beta"]

+    if "documentation" in template_config:
+        frontend_node["documentation"] = template_config["documentation"]
+

 def build_field_config(custom_component: CustomComponent):
    """Build the field configuration for a custom component"""
@ -257,26 +260,27 @@ def get_field_properties(extra_field):
    return field_name, field_type, field_value, field_required


-def add_base_classes(frontend_node, return_type):
+def add_base_classes(frontend_node, return_types: List[str]):
    """Add base classes to the frontend node"""
-    if return_type not in CUSTOM_COMPONENT_SUPPORTED_TYPES or return_type is None:
-        raise HTTPException(
-            status_code=400,
-            detail={
-                "error": (
-                    "Invalid return type should be one of: "
-                    f"{list(CUSTOM_COMPONENT_SUPPORTED_TYPES.keys())}"
-                ),
-                "traceback": traceback.format_exc(),
-            },
-        )
+    for return_type in return_types:
+        if return_type not in CUSTOM_COMPONENT_SUPPORTED_TYPES or return_type is None:
+            raise HTTPException(
+                status_code=400,
+                detail={
+                    "error": (
+                        "Invalid return type should be one of: "
+                        f"{list(CUSTOM_COMPONENT_SUPPORTED_TYPES.keys())}"
+                    ),
+                    "traceback": traceback.format_exc(),
+                },
+            )

-    return_type_instance = CUSTOM_COMPONENT_SUPPORTED_TYPES.get(return_type)
-    base_classes = get_base_classes(return_type_instance)
+        return_type_instance = CUSTOM_COMPONENT_SUPPORTED_TYPES.get(return_type)
+        base_classes = get_base_classes(return_type_instance)

-    for base_class in base_classes:
-        if base_class not in CLASSES_TO_REMOVE:
-            frontend_node.get("base_classes").append(base_class)
+        for base_class in base_classes:
+            if base_class not in CLASSES_TO_REMOVE:
+                frontend_node.get("base_classes").append(base_class)


 def build_langchain_template_custom_component(custom_component: CustomComponent):
--- a/src/backend/langflow/interface/utilities/base.py
+++ b/src/backend/langflow/interface/utilities/base.py
@ -5,7 +5,8 @@ from langchain import SQLDatabase, utilities
 from langflow.custom.customs import get_custom_nodes
 from langflow.interface.base import LangChainTypeCreator
 from langflow.interface.importing.utils import import_class
-from langflow.settings import settings
+from langflow.services.utils import get_settings_manager
+
 from langflow.template.frontend_node.utilities import UtilitiesFrontendNode
 from langflow.utils.logger import logger
 from langflow.utils.util import build_template_from_class
@ -26,6 +27,7 @@ class UtilityCreator(LangChainTypeCreator):
        from the langchain.chains module and filtering them according to the settings.utilities list.
        """
        if self.type_dict is None:
+            settings_manager = get_settings_manager()
            self.type_dict = {
                utility_name: import_class(f"langchain.utilities.{utility_name}")
                for utility_name in utilities.__all__
@ -35,7 +37,8 @@ class UtilityCreator(LangChainTypeCreator):
            self.type_dict = {
                name: utility
                for name, utility in self.type_dict.items()
-                if name in settings.UTILITIES or settings.DEV
+                if name in settings_manager.settings.UTILITIES
+                or settings_manager.settings.DEV
            }

        return self.type_dict
--- a/src/backend/langflow/interface/utils.py
+++ b/src/backend/langflow/interface/utils.py
@ -9,7 +9,8 @@ import yaml
 from langchain.base_language import BaseLanguageModel
 from PIL.Image import Image
 from langflow.utils.logger import logger
-from langflow.chat.config import ChatConfig
+from langflow.services.chat.config import ChatConfig
+from langflow.services.utils import get_settings_manager


 def load_file_into_dict(file_path: str) -> dict:
@ -63,13 +64,11 @@ def extract_input_variables_from_prompt(prompt: str) -> list[str]:

 def setup_llm_caching():
    """Setup LLM caching."""
-
-    from langflow.settings import settings
-
+    settings_manager = get_settings_manager()
    try:
-        set_langchain_cache(settings)
+        set_langchain_cache(settings_manager.settings)
    except ImportError:
-        logger.warning(f"Could not import {settings.CACHE}. ")
+        logger.warning(f"Could not import {settings_manager.settings.CACHE}. ")
    except Exception as exc:
        logger.warning(f"Could not setup LLM caching. Error: {exc}")

--- a/src/backend/langflow/interface/vector_store/base.py
+++ b/src/backend/langflow/interface/vector_store/base.py
@ -4,7 +4,8 @@ from langchain import vectorstores

 from langflow.interface.base import LangChainTypeCreator
 from langflow.interface.importing.utils import import_class
-from langflow.settings import settings
+from langflow.services.utils import get_settings_manager
+
 from langflow.template.frontend_node.vectorstores import VectorStoreFrontendNode
 from langflow.utils.logger import logger
 from langflow.utils.util import build_template_from_method
@ -43,10 +44,12 @@ class VectorstoreCreator(LangChainTypeCreator):
            return None

    def to_list(self) -> List[str]:
+        settings_manager = get_settings_manager()
        return [
            vectorstore
            for vectorstore in self.type_to_loader_dict.keys()
-            if vectorstore in settings.VECTORSTORES or settings.DEV
+            if vectorstore in settings_manager.settings.VECTORSTORES
+            or settings_manager.settings.DEV
        ]


--- a/src/backend/langflow/main.py
+++ b/src/backend/langflow/main.py
@ -6,24 +6,22 @@ from fastapi.responses import FileResponse
 from fastapi.staticfiles import StaticFiles

 from langflow.api import router
-from langflow.database.base import create_db_and_tables, Engine
+from langflow.routers import login, users, health
+
 from langflow.interface.utils import setup_llm_caching
+from langflow.services.database.utils import initialize_database
+from langflow.services.manager import initialize_services
 from langflow.utils.logger import configure


 def create_app():
    """Create the FastAPI app and include the router."""
+
    configure()

    app = FastAPI()

-    origins = [
-        "*",
-    ]
-
-    @app.get("/health")
-    def get_health():
-        return {"status": "OK"}
+    origins = ["*"]

    app.add_middleware(
        CORSMiddleware,
@ -33,9 +31,14 @@ def create_app():
        allow_headers=["*"],
    )

+    app.include_router(login.router)
+    app.include_router(users.router)
+    app.include_router(health.router)
+
    app.include_router(router)
-    app.on_event("startup")(Engine.update)
-    app.on_event("startup")(create_db_and_tables)
+
+    app.on_event("startup")(initialize_services)
+    app.on_event("startup")(initialize_database)
    app.on_event("startup")(setup_llm_caching)
    return app

@ -68,16 +71,19 @@ def get_static_files_dir():
    return frontend_path / "frontend"


-def setup_app(static_files_dir: Optional[Path] = None) -> FastAPI:
+def setup_app(
+    static_files_dir: Optional[Path] = None, backend_only: bool = False
+) -> FastAPI:
    """Setup the FastAPI app."""
    # get the directory of the current file
    if not static_files_dir:
        static_files_dir = get_static_files_dir()

-    if not static_files_dir or not static_files_dir.exists():
+    if not backend_only and (not static_files_dir or not static_files_dir.exists()):
        raise RuntimeError(f"Static files directory {static_files_dir} does not exist.")
    app = create_app()
-    setup_static_files(app, static_files_dir)
+    if not backend_only and static_files_dir is not None:
+        setup_static_files(app, static_files_dir)
    return app


--- a/src/backend/langflow/routers/init.py
+++ b/src/backend/langflow/routers/init.py
--- a/src/backend/langflow/routers/health.py
+++ b/src/backend/langflow/routers/health.py
@ -0,0 +1,8 @@
+from fastapi import APIRouter
+
+router = APIRouter()
+
+
+@router.get("/health")
+def get_health():
+    return {"status": "OK"}
--- a/src/backend/langflow/routers/login.py
+++ b/src/backend/langflow/routers/login.py
@ -0,0 +1,62 @@
+from uuid import UUID
+from sqlalchemy.orm import Session
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordRequestForm
+
+from langflow.services.utils import get_session
+from langflow.database.models.token import Token
+from langflow.auth.auth import (
+    authenticate_user,
+    create_user_tokens,
+    create_refresh_token,
+    create_user_longterm_token,
+)
+
+from langflow.services.utils import get_settings_manager
+
+router = APIRouter()
+
+
+@router.post("/login", response_model=Token)
+async def login_to_get_access_token(
+    form_data: OAuth2PasswordRequestForm = Depends(),
+    db: Session = Depends(get_session),
+    # _: Session = Depends(get_current_active_user)
+):
+    if user := authenticate_user(form_data.username, form_data.password, db):
+        return create_user_tokens(user_id=user.id, db=db, update_last_login=True)
+    else:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+
+
+@router.get("/auto_login")
+async def auto_login(db: Session = Depends(get_session)):
+    settings_manager = get_settings_manager()
+
+    if settings_manager.settings.AUTO_LOGIN:
+        user_id = UUID("3fa85f64-5717-4562-b3fc-2c963f66afa6")
+        return create_user_longterm_token(user_id, db)
+
+    raise HTTPException(
+        status_code=status.HTTP_400_BAD_REQUEST,
+        detail={
+            "message": "Auto login is disabled. Please enable it in the settings",
+            "auto_login": False,
+        },
+    )
+
+
+@router.post("/refresh")
+async def refresh_token(token: str):
+    if token:
+        return create_refresh_token(token)
+    else:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid refresh token",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
--- a/src/backend/langflow/routers/users.py
+++ b/src/backend/langflow/routers/users.py
@ -0,0 +1,133 @@
+from uuid import UUID
+
+from sqlalchemy import func
+from sqlalchemy.exc import IntegrityError
+
+from sqlmodel import Session, select
+from fastapi import APIRouter, Depends, HTTPException
+
+from langflow.services.utils import get_session
+from langflow.auth.auth import get_current_active_user, get_password_hash
+from langflow.database.models.user import (
+    User,
+    UserAddModel,
+    UserListModel,
+    UserPatchModel,
+    UsersResponse,
+    update_user,
+)
+
+router = APIRouter(tags=["Login"])
+
+
+@router.post("/user", response_model=UserListModel)
+def add_user(
+    user: UserAddModel,
+    db: Session = Depends(get_session),
+) -> User:
+    """
+    Add a new user to the database.
+    """
+    new_user = User(**user.dict())
+    try:
+        new_user.password = get_password_hash(user.password)
+
+        db.add(new_user)
+        db.commit()
+        db.refresh(new_user)
+    except IntegrityError as e:
+        db.rollback()
+        raise HTTPException(status_code=400, detail="User exists") from e
+
+    return new_user
+
+
+@router.get("/user", response_model=UserListModel)
+def read_current_user(current_user: User = Depends(get_current_active_user)) -> User:
+    """
+    Retrieve the current user's data.
+    """
+    return current_user
+
+
+@router.get("/users", response_model=UsersResponse)
+def read_all_users(
+    skip: int = 0,
+    limit: int = 10,
+    _: Session = Depends(get_current_active_user),
+    db: Session = Depends(get_session),
+) -> UsersResponse:
+    """
+    Retrieve a list of users from the database with pagination.
+    """
+    query = select(User).offset(skip).limit(limit)
+    users = db.execute(query).fetchall()
+
+    count_query = select(func.count()).select_from(User)  # type: ignore
+    total_count = db.execute(count_query).scalar()
+
+    return UsersResponse(
+        total_count=total_count,  # type: ignore
+        users=[UserListModel(**dict(user.User)) for user in users],
+    )
+
+
+@router.patch("/user/{user_id}", response_model=UserListModel)
+def patch_user(
+    user_id: UUID,
+    user: UserPatchModel,
+    _: Session = Depends(get_current_active_user),
+    db: Session = Depends(get_session),
+) -> User:
+    """
+    Update an existing user's data.
+    """
+    return update_user(user_id, user, db)
+
+
+@router.delete("/user/{user_id}")
+def delete_user(
+    user_id: UUID,
+    _: Session = Depends(get_current_active_user),
+    db: Session = Depends(get_session),
+) -> dict:
+    """
+    Delete a user from the database.
+    """
+    user_db = db.query(User).filter(User.id == user_id).first()
+    if not user_db:
+        raise HTTPException(status_code=404, detail="User not found")
+
+    db.delete(user_db)
+    db.commit()
+
+    return {"detail": "User deleted"}
+
+
+# TODO: REMOVE - Just for testing purposes
+@router.post("/super_user", response_model=User)
+def add_super_user_for_testing_purposes_delete_me_before_merge_into_dev(
+    db: Session = Depends(get_session),
+) -> User:
+    """
+    Add a superuser for testing purposes.
+    (This should be removed in production)
+    """
+    new_user = User(
+        username="superuser",
+        password="12345",
+        is_active=True,
+        is_superuser=True,
+        last_login_at=None,
+    )
+
+    try:
+        new_user.password = get_password_hash(new_user.password)
+        db.add(new_user)
+        db.commit()
+        db.refresh(new_user)
+    except IntegrityError as e:
+        db.rollback()
+        raise HTTPException(status_code=400, detail="User exists") from e
+
+    return new_user
--- a/src/backend/langflow/services/init.py
+++ b/src/backend/langflow/services/init.py
@ -0,0 +1,4 @@
+from .manager import service_manager
+from .schema import ServiceType
+
+__all__ = ["service_manager", "ServiceType"]
--- a/src/backend/langflow/services/base.py
+++ b/src/backend/langflow/services/base.py
@ -0,0 +1,2 @@
+class Service:
+    name: str
--- a/src/backend/langflow/services/cache/init.py
+++ b/src/backend/langflow/services/cache/init.py
@ -0,0 +1,11 @@
+from . import factory, manager
+from langflow.services.cache.manager import cache_manager
+from langflow.services.cache.flow import InMemoryCache
+
+
+__all__ = [
+    "cache_manager",
+    "factory",
+    "manager",
+    "InMemoryCache",
+]
--- a/src/backend/langflow/services/cache/base.py
+++ b/src/backend/langflow/services/cache/base.py
--- a/src/backend/langflow/services/cache/factory.py
+++ b/src/backend/langflow/services/cache/factory.py
@ -0,0 +1,11 @@
+from langflow.services.cache.manager import CacheManager
+from langflow.services.factory import ServiceFactory
+
+
+class CacheManagerFactory(ServiceFactory):
+    def __init__(self):
+        super().__init__(CacheManager)
+
+    def create(self, settings_service):
+        # Here you would have logic to create and configure a CacheManager
+        return CacheManager()
--- a/src/backend/langflow/services/cache/flow.py
+++ b/src/backend/langflow/services/cache/flow.py
@ -2,7 +2,7 @@ import threading
 import time
 from collections import OrderedDict

-from langflow.cache.base import BaseCache
+from langflow.services.cache.base import BaseCache


 class InMemoryCache(BaseCache):
--- a/src/backend/langflow/services/cache/manager.py
+++ b/src/backend/langflow/services/cache/manager.py
@ -1,5 +1,6 @@
 from contextlib import contextmanager
 from typing import Any, Awaitable, Callable, List, Optional
+from langflow.services.base import Service

 import pandas as pd
 from PIL import Image
@ -49,9 +50,11 @@ class AsyncSubject:
            await observer()


-class CacheManager(Subject):
+class CacheManager(Subject, Service):
    """Manages cache for different clients and notifies observers on changes."""

+    name = "cache_manager"
+
    def __init__(self):
        super().__init__()
        self._cache = {}
--- a/src/backend/langflow/services/cache/utils.py
+++ b/src/backend/langflow/services/cache/utils.py
--- a/src/backend/langflow/services/chat/init.py
+++ b/src/backend/langflow/services/chat/init.py
--- a/src/backend/langflow/services/chat/config.py
+++ b/src/backend/langflow/services/chat/config.py
--- a/src/backend/langflow/services/chat/factory.py
+++ b/src/backend/langflow/services/chat/factory.py
@ -0,0 +1,11 @@
+from langflow.services.chat.manager import ChatManager
+from langflow.services.factory import ServiceFactory
+
+
+class ChatManagerFactory(ServiceFactory):
+    def __init__(self):
+        super().__init__(ChatManager)
+
+    def create(self, settings_service):
+        # Here you would have logic to create and configure a ChatManager
+        return ChatManager()
--- a/src/backend/langflow/services/chat/manager.py
+++ b/src/backend/langflow/services/chat/manager.py
@ -1,10 +1,12 @@
 from collections import defaultdict
 from fastapi import WebSocket, status
 from langflow.api.v1.schemas import ChatMessage, ChatResponse, FileResponse
-from langflow.cache import cache_manager
-from langflow.cache.manager import Subject
-from langflow.chat.utils import process_graph
+from langflow.services.base import Service
+from langflow.services import service_manager
+from langflow.services.cache.manager import Subject
+from langflow.services.chat.utils import process_graph
 from langflow.interface.utils import pil_to_base64
+from langflow.services.schema import ServiceType
 from langflow.utils.logger import logger


@ -12,7 +14,7 @@ import asyncio
 import json
 from typing import Any, Dict, List

-from langflow.cache.flow import InMemoryCache
+from langflow.services.cache.flow import InMemoryCache


 class ChatHistory(Subject):
@ -42,11 +44,13 @@ class ChatHistory(Subject):
        self.history[client_id] = []


-class ChatManager:
+class ChatManager(Service):
+    name = "chat_manager"
+
    def __init__(self):
        self.active_connections: Dict[str, WebSocket] = {}
        self.chat_history = ChatHistory()
-        self.cache_manager = cache_manager
+        self.cache_manager = service_manager.get(ServiceType.CACHE_MANAGER)
        self.cache_manager.attach(self.update)
        self.in_memory_cache = InMemoryCache()

@ -117,7 +121,7 @@ class ChatManager:
        self, client_id: str, payload: Dict, langchain_object: Any
    ):
        # Process the graph data and chat message
-        chat_inputs = payload.pop("inputs", "")
+        chat_inputs = payload.pop("inputs", {})
        chat_inputs = ChatMessage(message=chat_inputs)
        self.chat_history.add_message(client_id, chat_inputs)

--- a/src/backend/langflow/services/chat/utils.py
+++ b/src/backend/langflow/services/chat/utils.py
@ -21,9 +21,9 @@ async def process_graph(

    # Generate result and thought
    try:
-        if not chat_inputs.message:
+        if chat_inputs.message is None:
            logger.debug("No message provided")
-            raise ValueError("No message provided")
+            chat_inputs.message = {}

        logger.debug("Generating result and thought")
        result, intermediate_steps = await get_result_and_steps(
--- a/src/backend/langflow/services/database/init.py
+++ b/src/backend/langflow/services/database/init.py
--- a/src/backend/langflow/services/database/factory.py
+++ b/src/backend/langflow/services/database/factory.py
@ -0,0 +1,17 @@
+from typing import TYPE_CHECKING
+from langflow.services.database.manager import DatabaseManager
+from langflow.services.factory import ServiceFactory
+
+if TYPE_CHECKING:
+    from langflow.services.settings.manager import SettingsManager
+
+
+class DatabaseManagerFactory(ServiceFactory):
+    def __init__(self):
+        super().__init__(DatabaseManager)
+
+    def create(self, settings_service: "SettingsManager"):
+        # Here you would have logic to create and configure a DatabaseManager
+        if not settings_service.settings.DATABASE_URL:
+            raise ValueError("No database URL provided")
+        return DatabaseManager(settings_service.settings.DATABASE_URL)
--- a/src/backend/langflow/services/database/manager.py
+++ b/src/backend/langflow/services/database/manager.py
@ -0,0 +1,84 @@
+from pathlib import Path
+from typing import TYPE_CHECKING
+from langflow.services.base import Service
+from langflow.services.utils import get_settings_manager
+from sqlmodel import SQLModel, Session, create_engine
+from langflow.utils.logger import logger
+from alembic.config import Config
+from alembic import command
+from langflow.services.database import models  # noqa
+
+if TYPE_CHECKING:
+    from sqlalchemy.engine import Engine
+
+
+class DatabaseManager(Service):
+    name = "database_manager"
+
+    def __init__(self, database_url: str):
+        self.database_url = database_url
+        # This file is in langflow.services.database.manager.py
+        # the ini is in langflow
+        langflow_dir = Path(__file__).parent.parent.parent
+        self.script_location = langflow_dir / "alembic"
+        self.alembic_cfg_path = langflow_dir / "alembic.ini"
+        self.engine = self._create_engine()
+
+    def _create_engine(self) -> "Engine":
+        """Create the engine for the database."""
+        settings_manager = get_settings_manager()
+        if (
+            settings_manager.settings.DATABASE_URL
+            and settings_manager.settings.DATABASE_URL.startswith("sqlite")
+        ):
+            connect_args = {"check_same_thread": False}
+        else:
+            connect_args = {}
+        return create_engine(self.database_url, connect_args=connect_args)
+
+    def __enter__(self):
+        self._session = Session(self.engine)
+        return self._session
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if exc_type is not None:  # If an exception has been raised
+            logger.error(
+                f"Session rollback because of exception: {exc_type.__name__} {exc_value}"
+            )
+            self._session.rollback()
+        else:
+            self._session.commit()
+        self._session.close()
+
+    def get_session(self):
+        with Session(self.engine) as session:
+            yield session
+
+    def run_migrations(self):
+        logger.info(
+            f"Running DB migrations in {self.script_location} on {self.database_url}"
+        )
+        alembic_cfg = Config()
+        alembic_cfg.set_main_option("script_location", str(self.script_location))
+        alembic_cfg.set_main_option("sqlalchemy.url", self.database_url)
+        command.upgrade(alembic_cfg, "head")
+
+    def create_db_and_tables(self):
+        logger.debug("Creating database and tables")
+        try:
+            SQLModel.metadata.create_all(self.engine)
+        except Exception as exc:
+            logger.error(f"Error creating database and tables: {exc}")
+            raise RuntimeError("Error creating database and tables") from exc
+
+        # Now check if the table "flow" exists, if not, something went wrong
+        # and we need to create the tables again.
+        from sqlalchemy import inspect
+
+        inspector = inspect(self.engine)
+        if "flow" not in inspector.get_table_names():
+            logger.error("Something went wrong creating the database and tables.")
+            logger.error("Please check your database settings.")
+            raise RuntimeError("Something went wrong creating the database and tables.")
+        else:
+            logger.debug("Database and tables created successfully")
--- a/src/backend/langflow/services/database/models/init.py
+++ b/src/backend/langflow/services/database/models/init.py
@ -0,0 +1,4 @@
+from .flow import Flow
+
+
+__all__ = ["Flow"]
--- a/src/backend/langflow/services/database/models/base.py
+++ b/src/backend/langflow/services/database/models/base.py
--- a/src/backend/langflow/services/database/models/component.py
+++ b/src/backend/langflow/services/database/models/component.py
@ -1,4 +1,4 @@
-from langflow.database.models.base import SQLModelSerializable, SQLModel
+from langflow.services.database.models.base import SQLModelSerializable, SQLModel
 from sqlmodel import Field
 from typing import Optional
 from datetime import datetime
--- a/src/backend/langflow/services/database/models/flow.py
+++ b/src/backend/langflow/services/database/models/flow.py
@ -1,13 +1,12 @@
 # Path: src/backend/langflow/database/models/flow.py

-from langflow.database.models.base import SQLModelSerializable
+from langflow.services.database.models.base import SQLModelSerializable
 from pydantic import validator
-from sqlmodel import Field, Relationship, JSON, Column
+from sqlmodel import Field, JSON, Column
 from uuid import UUID, uuid4
 from typing import Dict, Optional

 # if TYPE_CHECKING:
-from langflow.database.models.flow_style import FlowStyle, FlowStyleRead


 class FlowBase(SQLModelSerializable):
@ -35,11 +34,6 @@ class FlowBase(SQLModelSerializable):
 class Flow(FlowBase, table=True):
    id: UUID = Field(default_factory=uuid4, primary_key=True, unique=True)
    data: Optional[Dict] = Field(default=None, sa_column=Column(JSON))
-    style: Optional["FlowStyle"] = Relationship(
-        back_populates="flow",
-        # use "uselist=False" to make it a one-to-one relationship
-        sa_relationship_kwargs={"uselist": False},
-    )


 class FlowCreate(FlowBase):
@ -50,10 +44,6 @@ class FlowRead(FlowBase):
    id: UUID


-class FlowReadWithStyle(FlowRead):
-    style: Optional["FlowStyleRead"] = None
-
-
 class FlowUpdate(SQLModelSerializable):
    name: Optional[str] = None
    description: Optional[str] = None
--- a/src/backend/langflow/services/database/utils.py
+++ b/src/backend/langflow/services/database/utils.py
@ -0,0 +1,47 @@
+from typing import TYPE_CHECKING
+from langflow.utils.logger import logger
+from contextlib import contextmanager
+from alembic.util.exc import CommandError
+from sqlmodel import Session
+
+if TYPE_CHECKING:
+    from langflow.services.database.manager import DatabaseManager
+
+
+def initialize_database():
+    logger.debug("Initializing database")
+    from langflow.services import service_manager, ServiceType
+
+    database_manager = service_manager.get(ServiceType.DATABASE_MANAGER)
+    try:
+        database_manager.run_migrations()
+    except CommandError as exc:
+        if "Can't locate revision identified by" not in str(exc):
+            raise exc
+        # This means there's wrong revision in the DB
+        # We need to delete the alembic_version table
+        # and run the migrations again
+        logger.warning(
+            "Wrong revision in DB, deleting alembic_version table and running migrations again"
+        )
+        with session_getter(database_manager) as session:
+            session.execute("DROP TABLE alembic_version")
+        database_manager.run_migrations()
+    except Exception as exc:
+        logger.error(f"Error running migrations: {exc}")
+        raise RuntimeError("Error running migrations") from exc
+    database_manager.create_db_and_tables()
+    logger.debug("Database initialized")
+
+
+@contextmanager
+def session_getter(db_manager: "DatabaseManager"):
+    try:
+        session = Session(db_manager.engine)
+        yield session
+    except Exception as e:
+        print("Session rollback because of exception:", e)
+        session.rollback()
+        raise
+    finally:
+        session.close()
--- a/Show more
+++ b/Show more