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

2023-08-17 16:17:14 -03:00 · 2023-08-17 16:17:14 -03:00 · 11a2d12c6b
commit 11a2d12c6b
parent 2426656b93 2078778976
245 changed files with 18156 additions and 6877 deletions
--- a/.devcontainer/demo/devcontainer.json
+++ b/.devcontainer/demo/devcontainer.json
@ -15,7 +15,8 @@
 				"actboy168.tasks",
 				"GitHub.copilot",
 				"ms-python.python",
-				"eamodio.gitlens"
+				"eamodio.gitlens",
+				"GitHub.vscode-pull-request-github"
 			]
 		}
 	},
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@ -3,32 +3,36 @@
 {
 	"name": "LangChain Dev Container",
 	// Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
-	"image": "mcr.microsoft.com/devcontainers/universal:2-linux",
+	"image": "mcr.microsoft.com/devcontainers/python:1-3.10-bullseye",
+	
+	// Features to add to the dev container. More info: https://containers.dev/features.
 	"features": {
-		"ghcr.io/devcontainers/features/aws-cli:1": {},
-		"ghcr.io/devcontainers/features/docker-in-docker": {}
+		"ghcr.io/devcontainers/features/node": {},
+		"ghcr.io/devcontainers-contrib/features/poetry": {}
 	},
+
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+
+	// Use 'postCreateCommand' to run commands after the container is created.
+	"postCreateCommand": "make setup_devcontainer",
+
+	"containerEnv": {
+		"POETRY_VIRTUALENVS_IN_PROJECT": "true"
+	},
+
+	// Configure tool-specific properties.
 	"customizations": {
 		"vscode": {"extensions": [
 				"actboy168.tasks",
 				"GitHub.copilot",
 				"ms-python.python",
 				"sourcery.sourcery",
-				"eamodio.gitlens"
+				"eamodio.gitlens",
+				"ms-vscode.makefile-tools",
+				"GitHub.vscode-pull-request-github"
 			]}
-	},
-
-	// Features to add to the dev container. More info: https://containers.dev/features.
-	// "features": {},
-
-	// Use 'forwardPorts' to make a list of ports inside the container available locally.
-	// "forwardPorts": [],
-
-	// Use 'postCreateCommand' to run commands after the container is created.
-	"postCreateCommand": "poetry install"
-
-	// Configure tool-specific properties.
-	// "customizations": {},
+	}

 	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
 	// "remoteUser": "root"
--- a/.dockerignore
+++ b/.dockerignore
@ -0,0 +1 @@
+.venv/
--- a/.gitattributes
+++ b/.gitattributes
@ -0,0 +1,20 @@
+# Set the default behavior, in case people don't have core.autocrlf set.
+* text eol=lf
+
+# Explicitly declare text files you want to always be normalized and converted
+# to native line endings on checkout.
+*.c text
+*.h text
+*.py text
+*.js text
+*.ts text
+*.jsx text
+*.md text
+*.mdx text
+
+# Declare files that will always have CRLF line endings on checkout.
+*.sln text eol=crlf
+
+# Denote all files that are truly binary and should not be modified.
+*.png binary
+*.jpg binary
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@ -14,9 +14,7 @@ env:

 jobs:
  if_release:
-    if: |
-      ${{ github.event.pull_request.merged == true }}
-      && ${{ contains(github.event.pull_request.labels.*.name, 'Release') }}
+    if: ${{ (github.event.pull_request.merged == true) && contains(github.event.pull_request.labels.*.name, 'Release') }}
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
--- 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/14
+++ b/14
@ -32,15 +32,27 @@ lint:
 	poetry run ruff . --fix

 install_frontend:
-	cd src/frontend && npm install
+	cd src/frontend && npm install;
+
+install_frontendc:
+	cd src/frontend && rm -rf node_modules package-lock.json && npm install;

 run_frontend:
 	cd src/frontend && npm start

+setup_devcontainer:
+	make init
+	make build_frontend
+	poetry run langflow --path src/frontend/build
+
 frontend:
 	make install_frontend
 	make run_frontend

+frontendc:
+	make install_frontendc
+	make run_frontend
+
 install_backend:
 	poetry install

--- a/README.md
+++ b/README.md
@ -33,7 +33,7 @@
  - [HuggingFace Spaces](#huggingface-spaces)
 - [🖥️ Command Line Interface (CLI)](#️-command-line-interface-cli)
  - [Usage](#usage)
-  - [Environment Variables](#environment-variables)
+    - [Environment Variables](#environment-variables)
 - [Deployment](#deployment)
  - [Deploy Langflow on Google Cloud Platform](#deploy-langflow-on-google-cloud-platform)
  - [Deploy Langflow on Jina AI Cloud](#deploy-langflow-on-jina-ai-cloud)
@ -112,7 +112,6 @@ Each option is detailed below:
 - `--cache`: Selects the type of cache to use. Options are `InMemoryCache` and `SQLiteCache`. Can be set using the `LANGFLOW_LANGCHAIN_CACHE` environment variable. The default is `SQLiteCache`.
 - `--jcloud/--no-jcloud`: Toggles the option to deploy on Jina AI Cloud. The default is `no-jcloud`.
 - `--dev/--no-dev`: Toggles the development mode. The default is `no-dev`.
- `--database-url`: Sets the database URL to connect to. If not provided, a local SQLite database will be used. Can be set using the `LANGFLOW_DATABASE_URL` environment variable.
 - `--path`: Specifies the path to the frontend directory containing build files. This option is for development purposes only. Can be set using the `LANGFLOW_FRONTEND_PATH` environment variable.
 - `--open-browser/--no-open-browser`: Toggles the option to open the browser after starting the server. Can be set using the `LANGFLOW_OPEN_BROWSER` environment variable. The default is `open-browser`.
 - `--remove-api-keys/--no-remove-api-keys`: Toggles the option to remove API keys from the projects saved in the database. Can be set using the `LANGFLOW_REMOVE_API_KEYS` environment variable. The default is `no-remove-api-keys`.
@ -276,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,28 +1,33 @@
-version: '3.4'
-
-services:
-  backend:
-    volumes:
-      - ./:/app
-    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"]
-    ports:
-      - 7860:7860
-      - 5678:5678
-    restart: on-failure
-
-  frontend:
-    build:
-      context: ./src/frontend
-      dockerfile: ./dev.Dockerfile
-      args:
-        - BACKEND_URL=http://backend:7860
-    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
+version: "3.4"
+
+services:
+  backend:
+    volumes:
+      - ./:/app
+    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 --factory src.backend.langflow.main:create_app --host 0.0.0.0 --port 7860 --reload",
+      ]
+    ports:
+      - 7860:7860
+      - 5678:5678
+    restart: on-failure
+
+  frontend:
+    build:
+      context: ./src/frontend
+      dockerfile: ./dev.Dockerfile
+      args:
+        - BACKEND_URL=http://backend:7860
+    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
--- 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/components/tools.mdx
+++ b/docs/docs/components/tools.mdx
@ -6,4 +6,58 @@ import Admonition from '@theme/Admonition';
    <p>
        We appreciate your understanding as we polish our documentation – it may contain some rough edges. Share your feedback or report issues to help us improve! 🛠️📝
    </p>
-</Admonition>
+</Admonition>
+
+
+### BingSearchRun
+
+Bing Search is a web search engine owned and operated by Microsoft. It provides search results for various types of content, including web pages, images, videos, and news articles. It uses a combination of algorithms and human editors to deliver search results to users.
+
+**Params**
+
+- **Api Wrapper:** A BingSearchAPIWrapper component that takes the search URL and a subscription key.
+
+
+### Calculator
+
+The calculator tool provides mathematical calculation capabilities to an agent by leveraging an LLMMathChain. It allows the agent to perform math when needed to answer questions.
+
+**Params**
+
+- **LLM:** Language Model to use in the calculation.
+
+
+### GoogleSearchResults
+
+A wrapper around Google Search. Useful for when the user needs to answer questions about with more control over the JSON data returned from the API. It returns the full JSON response configured based on the parameters passed to the API wrapper.
+
+**Params**
+
+- **Api Wrapper:** A GoogleSearchAPIWrapper with Google API key and CSE ID
+
+
+### GoogleSearchRun
+
+A quick wrapper around Google Search. It executes the search query and returns just the first result snippet from the highest-priority result type.
+
+**Params**
+
+- **Api Wrapper:** A GoogleSearchAPIWrapper with Google API key and CSE ID
+
+
+### GoogleSerperRun
+
+A low-cost Google Search API.
+
+**Params**
+
+- **Api Wrapper:** A GoogleSerperAPIWrapper component with API key and result keys
+
+
+### InfoSQLDatabaseTool
+
+Tool for getting metadata about a SQL database. The input to this tool is a comma-separated list of tables, and the output is the schema and sample rows for those tables. Example Input: `“table1`, `table2`, `table3”`.
+
+**Params**
+
+- **Db:** SQLDatabase to query.
--- 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",
@ -385,19 +384,19 @@ Your structure should look something like this:

 ### Loading Custom Components

-You can specify the path to your custom components using the _`--components-path`_ argument when running the Langflow CLI, as shown below:
-
-```bash
-langflow --components-path /path/to/components
-```
-
-Alternatively, you can set the `LANGFLOW_COMPONENTS_PATH` environment variable:
+The recommended way to load custom components is to set the _`LANGFLOW_COMPONENTS_PATH`_ environment variable to the path of your custom components directory. Then, run the Langflow CLI as usual.

 ```bash
 export LANGFLOW_COMPONENTS_PATH=/path/to/components
 langflow
 ```

+Alternatively, you can specify the path to your custom components using the _`--components-path`_ argument when running the Langflow CLI, as shown below:
+
+```bash
+langflow --components-path /path/to/components
+```
+
 Langflow will attempt to load all of the components found in the specified directory. If a component fails to load due to errors in the component's code, Langflow will print an error message to the console but will continue loading the rest of the components.

 ### Interacting with Custom Components
--- 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
--- a/poetry.lock
+++ b/poetry.lock
--- a/pyproject.toml
+++ b/pyproject.toml
@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langflow"
-version = "0.4.0"
+version = "0.4.11"
 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"
@ -33,7 +33,7 @@ google-search-results = "^2.4.1"
 google-api-python-client = "^2.79.0"
 typer = "^0.9.0"
 gunicorn = "^21.1.0"
-langchain = "^0.0.250"
+langchain = "^0.0.256"
 openai = "^0.27.8"
 pandas = "^2.0.0"
 chromadb = "^0.3.21"
@ -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"
@ -76,6 +76,12 @@ google-cloud-aiplatform = "^1.26.1"
 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"
@ -91,6 +97,8 @@ pandas-stubs = "^2.0.0.230412"
 types-pillow = "^9.5.0.2"
 types-appdirs = "^1.4.3.5"
 types-pyyaml = "^6.0.12.8"
+types-python-jose = "^3.3.4.8"
+types-passlib = "^1.7.7.13"


 [tool.poetry.extras]
--- 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,7 +1,8 @@
-import os
 import sys
 import time
 import httpx
+from langflow.services.manager import initialize_settings_manager
+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
@ -13,7 +14,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
@ -25,49 +25,26 @@ def update_settings(
    config: str,
    cache: str,
    dev: bool = False,
-    database_url: Optional[str] = None,
    remove_api_keys: bool = False,
    components_path: Optional[Path] = None,
 ):
    """Update the settings from a config file."""

    # Check for database_url in the environment variables
-    database_url = database_url or os.getenv("langflow_database_url")
-
+    initialize_settings_manager()
+    settings_manager = get_settings_manager()
    if config:
        logger.debug(f"Loading settings from {config}")
-        settings.update_from_yaml(config, dev=dev)
-    if database_url:
-        settings.update_settings(database_url=database_url)
+        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)
-
-
-def load_params():
-    """
-    Load the parameters from the environment variables.
-    """
-    global_vars = globals()
-
-    for key, value in global_vars.items():
-        env_key = f"LANGFLOW_{key.upper()}"
-        if env_key in os.environ:
-            if isinstance(value, bool):
-                # Handle booleans
-                global_vars[key] = os.getenv(env_key, str(value)).lower() == "true"
-            elif isinstance(value, int):
-                # Handle integers
-                global_vars[key] = int(os.getenv(env_key, str(value)))
-            elif isinstance(value, str) or value is None:
-                # Handle strings and None values
-                global_vars[key] = os.getenv(env_key, str(value))
+        settings_manager.settings.update_settings(COMPONENTS_PATH=components_path)


 def serve_on_jcloud():
@ -131,10 +108,12 @@ 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(
-        ".env", help="Path to the .env file containing environment variables."
+        None, help="Path to the .env file containing environment variables."
    ),
    log_level: str = typer.Option(
        "critical", help="Logging level.", envvar="LANGFLOW_LOG_LEVEL"
@ -149,11 +128,13 @@ def serve(
    ),
    jcloud: bool = typer.Option(False, help="Deploy on Jina AI Cloud"),
    dev: bool = typer.Option(False, help="Run in development mode (may contain bugs)"),
-    database_url: str = typer.Option(
-        None,
-        help="Database URL to connect to. If not provided, a local SQLite database will be used.",
-        envvar="LANGFLOW_DATABASE_URL",
-    ),
+    # This variable does not work but is set by the .env file
+    # and works with Pydantic
+    # database_url: str = typer.Option(
+    #     None,
+    #     help="Database URL to connect to. If not provided, a local SQLite database will be used.",
+    #     envvar="LANGFLOW_DATABASE_URL",
+    # ),
    path: str = typer.Option(
        None,
        help="Path to the frontend directory containing build files. This is for development purposes only.",
@ -169,6 +150,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.
@ -176,7 +162,6 @@ def serve(
    # override env variables with .env file
    if env_file:
        load_dotenv(env_file, override=True)
-        load_params()

    if jcloud:
        return serve_on_jcloud()
@ -185,14 +170,13 @@ def serve(
    update_settings(
        config,
        dev=dev,
-        database_url=database_url,
        remove_api_keys=remove_api_keys,
        cache=cache,
        components_path=components_path,
    )
    # 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)
@ -204,6 +188,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/utils.py
+++ b/src/backend/langflow/api/utils.py
@ -66,3 +66,30 @@ def merge_nested_dicts(dict1, dict2):
        else:
            dict1[key] = value
    return dict1
+
+
+def merge_nested_dicts_with_renaming(dict1, dict2):
+    for key, value in dict2.items():
+        if (
+            key in dict1
+            and isinstance(value, dict)
+            and isinstance(dict1.get(key), dict)
+        ):
+            for sub_key, sub_value in value.items():
+                if sub_key in dict1[key]:
+                    new_key = get_new_key(dict1[key], sub_key)
+                    dict1[key][new_key] = sub_value
+                else:
+                    dict1[key][sub_key] = sub_value
+        else:
+            dict1[key] = value
+    return dict1
+
+
+def get_new_key(dictionary, original_key):
+    counter = 1
+    new_key = original_key + " (" + str(counter) + ")"
+    while new_key in dictionary:
+        counter += 1
+        new_key = original_key + " (" + str(counter) + ")"
+    return new_key
--- 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)
@ -125,9 +127,8 @@ async def stream_build(flow_id: str):
                    vertex.build()
                    params = vertex._built_object_repr()
                    valid = True
-                    logger.debug(
-                        f"Building node {str(params)[:50]}{'...' if len(str(params)) > 50 else ''}"
-                    )
+                    logger.debug(f"Building node {str(vertex.vertex_type)}")
+                    logger.debug(f"Output: {params}")
                    if vertex.artifacts:
                        # The artifacts will be prompt variables
                        # passed to build_input_keys_response
@ -156,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,19 +1,15 @@
 from http import HTTPStatus
-from typing import Annotated, Optional
+from typing import Annotated, Optional, Union

-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

-from langflow.interface.custom.directory_reader import (
-    CustomComponentPathValueError,
-)

 from langflow.api.v1.schemas import (
    ProcessResponse,
@ -21,7 +17,7 @@ from langflow.api.v1.schemas import (
    CustomComponentCode,
 )

-from langflow.api.utils import merge_nested_dicts
+from langflow.api.utils import merge_nested_dicts_with_renaming

 from langflow.interface.types import (
    build_langchain_types_dict,
@ -29,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
@ -38,48 +34,44 @@ router = APIRouter(tags=["Base"])

@router.get("/all")
 def get_all():
+    logger.debug("Building langchain types dict")
    native_components = build_langchain_types_dict()
-
    # custom_components is a list of dicts
    # need to merge all the keys into one dict
    custom_components_from_file = {}
-    if settings.components_path:
-        custom_component_dicts = [
-            build_langchain_custom_component_list_from_path(str(path))
-            for path in 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 = []
+        processed_paths = []
+        for path in settings_manager.settings.COMPONENTS_PATH:
+            if str(path) in processed_paths:
+                continue
+            custom_component_dict = build_langchain_custom_component_list_from_path(
+                str(path)
+            )
+            custom_component_dicts.append(custom_component_dict)
+            processed_paths.append(str(path))
+
+        logger.info(f"Loading {len(custom_component_dicts)} category(ies)")
        for custom_component_dict in custom_component_dicts:
-            custom_components_from_file = merge_nested_dicts(
+            # custom_component_dict is a dict of dicts
+            category = list(custom_component_dict.keys())[0]
+            logger.info(
+                f"Loading {len(custom_component_dict[category])} component(s) from category {category}"
+            )
+            logger.debug(custom_component_dict)
+            custom_components_from_file = merge_nested_dicts_with_renaming(
                custom_components_from_file, custom_component_dict
            )
-    return merge_nested_dicts(native_components, custom_components_from_file)

-
-@router.get("/load_custom_component_from_path")
-def get_load_custom_component_from_path(path: str):
-    try:
-        data = build_langchain_custom_component_list_from_path(path)
-    except CustomComponentPathValueError as err:
-        raise HTTPException(
-            status_code=400,
-            detail={"error": type(err).__name__, "traceback": str(err)},
-        ) from err
-
-    return data
-
-
-@router.get("/load_custom_component_from_path_TEST")
-def get_load_custom_component_from_path_test(path: str):
-    from langflow.interface.custom.directory_reader import (
-        DirectoryReader,
+    return merge_nested_dicts_with_renaming(
+        native_components, custom_components_from_file
    )

-    reader = DirectoryReader(path, False)
-    file_list = reader.get_files()
-    data = reader.build_component_menu_list(file_list)
-
-    return reader.filter_loaded_components(data, True)
-

 # For backwards compatibility we will keep the old endpoint
@router.post("/predict/{flow_id}", response_model=ProcessResponse)
@ -89,6 +81,7 @@ async def process_flow(
    inputs: Optional[dict] = None,
    tweaks: Optional[dict] = None,
    clear_cache: Annotated[bool, Body(embed=True)] = False,  # noqa: F821
+    session_id: Annotated[Union[None, str], Body(embed=True)] = None,  # noqa: F821
    session: Session = Depends(get_session),
 ):
    """
@ -108,10 +101,10 @@ async def process_flow(
                graph_data = process_tweaks(graph_data, tweaks)
            except Exception as exc:
                logger.error(f"Error processing tweaks: {exc}")
-        response = process_graph_cached(graph_data, inputs, clear_cache)
-        return ProcessResponse(
-            result=response,
+        response, session_id = process_graph_cached(
+            graph_data, inputs, clear_cache, session_id
        )
+        return ProcessResponse(result=response, session_id=session_id)
    except Exception as e:
        # Log stack trace
        logger.exception(e)
--- 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

@ -47,6 +47,7 @@ class ProcessResponse(BaseModel):
    """Process response schema."""

    result: dict
+    session_id: Optional[str] = None


 class ChatMessage(BaseModel):
--- 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/init.py
+++ b/src/backend/langflow/components/init.py
@ -0,0 +1,4 @@
+from langflow.interface.custom.custom_component import CustomComponent
+
+
+__all__ = ["CustomComponent"]
--- a/src/backend/langflow/components/agents/OpenAIConversationalAgent.py
+++ b/src/backend/langflow/components/agents/OpenAIConversationalAgent.py
@ -0,0 +1,82 @@
+from langflow import CustomComponent
+from typing import Optional
+from langchain.prompts import SystemMessagePromptTemplate
+from langchain.tools import Tool
+from langchain.schema.memory import BaseMemory
+from langchain.chat_models import ChatOpenAI
+
+from langchain.agents.agent import AgentExecutor
+from langchain.agents.openai_functions_agent.base import OpenAIFunctionsAgent
+from langchain.memory.token_buffer import ConversationTokenBufferMemory
+from langchain.prompts.chat import MessagesPlaceholder
+from langchain.agents.agent_toolkits.conversational_retrieval.openai_functions import (
+    _get_default_system_message,
+)
+
+
+class ConversationalAgent(CustomComponent):
+    display_name: str = "OpenAI Conversational Agent"
+    description: str = "Conversational Agent that can use OpenAI's function calling API"
+
+    def build_config(self):
+        openai_function_models = [
+            "gpt-3.5-turbo-0613",
+            "gpt-3.5-turbo-16k-0613",
+            "gpt-4-0613",
+            "gpt-4-32k-0613",
+        ]
+        return {
+            "tools": {"is_list": True, "display_name": "Tools"},
+            "memory": {"display_name": "Memory"},
+            "system_message": {"display_name": "System Message"},
+            "max_token_limit": {"display_name": "Max Token Limit"},
+            "model_name": {
+                "display_name": "Model Name",
+                "options": openai_function_models,
+                "value": openai_function_models[0],
+            },
+            "code": {"show": False},
+        }
+
+    def build(
+        self,
+        model_name: str,
+        openai_api_key: str,
+        openai_api_base: str,
+        tools: Tool,
+        memory: Optional[BaseMemory] = None,
+        system_message: Optional[SystemMessagePromptTemplate] = None,
+        max_token_limit: int = 2000,
+    ) -> AgentExecutor:
+        llm = ChatOpenAI(
+            model=model_name,
+            openai_api_key=openai_api_key,
+            openai_api_base=openai_api_base,
+        )
+        if not memory:
+            memory_key = "chat_history"
+            memory = ConversationTokenBufferMemory(
+                memory_key=memory_key,
+                return_messages=True,
+                output_key="output",
+                llm=llm,
+                max_token_limit=max_token_limit,
+            )
+        else:
+            memory_key = memory.memory_key  # type: ignore
+
+        _system_message = system_message or _get_default_system_message()
+        prompt = OpenAIFunctionsAgent.create_prompt(
+            system_message=_system_message,  # type: ignore
+            extra_prompt_messages=[MessagesPlaceholder(variable_name=memory_key)],
+        )
+        agent = OpenAIFunctionsAgent(
+            llm=llm, tools=tools, prompt=prompt  # type: ignore
+        )
+        return AgentExecutor(
+            agent=agent,
+            tools=tools,  # type: ignore
+            memory=memory,
+            verbose=True,
+            return_intermediate_steps=True,
+        )
--- a/src/backend/langflow/components/agents/init.py
+++ b/src/backend/langflow/components/agents/init.py
--- a/src/backend/langflow/components/chains/PromptRunner.py
+++ b/src/backend/langflow/components/chains/PromptRunner.py
@ -0,0 +1,33 @@
+from langflow import CustomComponent
+
+from langchain.llms.base import BaseLLM
+from langchain import PromptTemplate
+from langchain.schema import Document
+
+
+class PromptRunner(CustomComponent):
+    display_name: str = "Prompt Runner"
+    description: str = "Run a Chain with the given PromptTemplate"
+    beta = True
+    field_config = {
+        "llm": {"display_name": "LLM"},
+        "prompt": {
+            "display_name": "Prompt Template",
+            "info": "Make sure the prompt has all variables filled.",
+        },
+        "code": {"show": False},
+        "inputs": {"field_type": "code"},
+    }
+
+    def build(
+        self,
+        llm: BaseLLM,
+        prompt: PromptTemplate,
+    ) -> Document:
+        chain = prompt | llm
+        # The input is an empty dict because the prompt is already filled
+        result = chain.invoke({})
+        if hasattr(result, "content"):
+            result = result.content
+        self.repr_value = result
+        return Document(page_content=str(result))
--- a/src/backend/langflow/components/chains/init.py
+++ b/src/backend/langflow/components/chains/init.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,51 +0,0 @@
-from contextlib import contextmanager
-from langflow.settings import settings
-from sqlmodel import SQLModel, Session, create_engine
-from langflow.utils.logger import logger
-
-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")
-engine = create_engine(settings.database_url, connect_args=connect_args)
-
-
-def create_db_and_tables():
-    logger.debug("Creating database and tables")
-    try:
-        SQLModel.metadata.create_all(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(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")
-
-
-@contextmanager
-def session_getter():
-    try:
-        session = Session(engine)
-        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/utils.py
+++ b/src/backend/langflow/graph/utils.py
@ -3,6 +3,10 @@ from typing import Any, Union
 from langflow.interface.utils import extract_input_variables_from_prompt


+class UnbuiltObject:
+    pass
+
+
 def validate_prompt(prompt: str):
    """Validate prompt."""
    if extract_input_variables_from_prompt(prompt):
--- a/src/backend/langflow/graph/vertex/base.py
+++ b/src/backend/langflow/graph/vertex/base.py
@ -1,5 +1,7 @@
+import ast
+from langflow.graph.utils import UnbuiltObject
 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
@ -21,7 +23,7 @@ class Vertex:
        self.edges: List["Edge"] = []
        self.base_type: Optional[str] = base_type
        self._parse_data()
-        self._built_object = None
+        self._built_object = UnbuiltObject()
        self._built = False
        self.artifacts: Dict[str, Any] = {}

@ -61,7 +63,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
@ -100,7 +102,9 @@ class Vertex:
                    params[param_key] = edge.source

        for key, value in template_dict.items():
-            if key == "_type" or not value.get("show"):
+            # Skip _type and any value that has show == False and is not code
+            # If we don't want to show code but we want to use it
+            if key == "_type" or (not value.get("show") and key != "code"):
                continue
            # If the type is not transformable to a python base class
            # then we need to get the edge that connects to this node
@ -112,7 +116,14 @@ class Vertex:

                params[key] = file_path
            elif value.get("type") in DIRECT_TYPES and params.get(key) is None:
-                params[key] = value.get("value")
+                if value.get("type") == "code":
+                    try:
+                        params[key] = ast.literal_eval(value.get("value"))
+                    except Exception as exc:
+                        logger.debug(f"Error parsing code: {exc}")
+                        params[key] = value.get("value")
+                else:
+                    params[key] = value.get("value")

            if not value.get("required") and params.get(key) is None:
                if value.get("default"):
@ -235,8 +246,14 @@ class Vertex:
        """
        Checks if the built object is None and raises a ValueError if so.
        """
-        if self._built_object is None:
-            raise ValueError(f"Node type {self.vertex_type} not found")
+        if isinstance(self._built_object, UnbuiltObject):
+            raise ValueError(f"{self.vertex_type}: {self._built_object_repr()}")
+        elif self._built_object is None:
+            message = f"{self.vertex_type} returned None."
+            if self.base_type == "custom_components":
+                message += " Make sure your build method returns a component."
+
+            raise ValueError(message)

    def build(self, force: bool = False) -> Any:
        if not self._built or force:
@ -259,4 +276,8 @@ class Vertex:

    def _built_object_repr(self):
        # Add a message with an emoji, stars for sucess,
-        return "Built sucessfully ✨" if self._built_object else "Failed to build 😵‍💫"
+        return (
+            "Built sucessfully ✨"
+            if self._built_object is not None
+            else "Failed to build 😵‍💫"
+        )
--- a/src/backend/langflow/graph/vertex/types.py
+++ b/src/backend/langflow/graph/vertex/types.py
@ -226,7 +226,16 @@ class PromptVertex(Vertex):
        # so the prompt format doesn't break
        artifacts.pop("handle_keys", None)
        try:
-            template = self._built_object.format(**artifacts)
+            if not hasattr(self._built_object, "template") and hasattr(
+                self._built_object, "prompt"
+            ):
+                template = self._built_object.prompt.template
+            else:
+                template = self._built_object.template
+            for key, value in artifacts.items():
+                if value:
+                    replace_key = "{" + key + "}"
+                    template = template.replace(replace_key, value)
            return (
                template
                if isinstance(template, str)
--- 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)
+                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,11 +3,13 @@ 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
 from langchain import chains
+from langchain_experimental.sql import SQLDatabaseChain  # type: ignore

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

@ -29,18 +31,22 @@ 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__
            }
            from langflow.interface.chains.custom import CUSTOM_CHAINS

+            self.type_dict["SQLDatabaseChain"] = SQLDatabaseChain
+
            self.type_dict.update(CUSTOM_CHAINS)
            # Filter according to settings.chains
            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
@ -1,5 +1,5 @@
 import ast
-from typing import Optional
+from typing import Any, Optional
 from pydantic import BaseModel
 from fastapi import HTTPException

@ -63,10 +63,13 @@ class Component(BaseModel):
                elif "description" in item_name:
                    template_config["description"] = ast.literal_eval(item_value)

-                elif "field_config" in item_name:
-                    template_config["field_config"] = ast.literal_eval(item_value)
+                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):
+    def build(self, *args: Any, **kwargs: Any) -> Any:
        raise NotImplementedError
--- a/src/backend/langflow/interface/custom/constants.py
+++ b/src/backend/langflow/interface/custom/constants.py
@ -7,10 +7,14 @@ from langchain.schema import BaseRetriever, Document
 from langchain.text_splitter import TextSplitter
 from langchain.tools import Tool
 from langchain.vectorstores.base import VectorStore
-
+from langchain.schema import BaseOutputParser
+from langchain.schema.memory import BaseMemory
+from langchain.memory.chat_memory import BaseChatMemory
+from langchain.agents.agent import AgentExecutor

 LANGCHAIN_BASE_TYPES = {
    "Chain": Chain,
+    "AgentExecutor": AgentExecutor,
    "Tool": Tool,
    "BaseLLM": BaseLLM,
    "PromptTemplate": PromptTemplate,
@ -20,6 +24,9 @@ LANGCHAIN_BASE_TYPES = {
    "VectorStore": VectorStore,
    "Embeddings": Embeddings,
    "BaseRetriever": BaseRetriever,
+    "BaseOutputParser": BaseOutputParser,
+    "BaseMemory": BaseMemory,
+    "BaseChatMemory": BaseChatMemory,
 }

 # Langchain base types plus Python base types
--- a/src/backend/langflow/interface/custom/custom_component.py
+++ b/src/backend/langflow/interface/custom/custom_component.py
@ -3,12 +3,14 @@ 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


 class CustomComponent(Component, extra=Extra.allow):
@ -24,6 +26,10 @@ class CustomComponent(Component, extra=Extra.allow):
        super().__init__(**data)

    def custom_repr(self):
+        if isinstance(self.repr_value, dict):
+            return yaml.dump(self.repr_value)
+        if isinstance(self.repr_value, str):
+            return self.repr_value
        return str(self.repr_value)

    def build_config(self):
@ -44,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(
+                type_hint, code
+            ) and not reader._is_type_hint_imported(type_hint, code):
                error_detail = {
                    "error": "Type hint Error",
                    "traceback": f"Type hint '{type_hint}' is used but not imported in the code.",
@ -87,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 = [
@ -98,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]
@ -109,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):
@ -154,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")
@ -164,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

@ -177,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:
@ -190,5 +210,5 @@ class CustomComponent(Component, extra=Extra.allow):
            raise ValueError(f"Flow {flow_name or flow_id} not found")
        return self.load_flow(flow.id, tweaks)

-    def build(self):
+    def build(self, *args: Any, **kwargs: Any) -> Any:
        raise NotImplementedError
--- a/src/backend/langflow/interface/custom/directory_reader.py
+++ b/src/backend/langflow/interface/custom/directory_reader.py
@ -1,6 +1,7 @@
 import os
 import ast
 import zlib
+from langflow.utils.logger import logger


 class CustomComponentPathValueError(ValueError):
@ -74,8 +75,11 @@ class DirectoryReader:
            }
            for menu in data["menu"]
        ]
-        filtred = [menu for menu in items if menu["components"]]
-        return {"menu": filtred}
+        filtered = [menu for menu in items if menu["components"]]
+        logger.debug(
+            f'Filtered components {"with errors" if with_errors else ""}: {filtered}'
+        )
+        return {"menu": filtered}

    def validate_code(self, file_content):
        """
@ -116,7 +120,7 @@ class DirectoryReader:
            file_list.extend(
                os.path.join(root, filename)
                for filename in files
-                if filename.endswith(".py")
+                if filename.endswith(".py") and not filename.startswith("__")
            )
        return file_list

@ -148,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:
@ -200,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())
@ -213,27 +226,47 @@ class DirectoryReader:
        from the .py files in the directory.
        """
        response = {"menu": []}
+        logger.debug(
+            "-------------------- Building component menu list --------------------"
+        )

        for file_path in file_paths:
            menu_name = os.path.basename(os.path.dirname(file_path))
+            logger.debug(f"Menu name: {menu_name}")
            filename = os.path.basename(file_path)
            validation_result, result_content = self.process_file(file_path)
+            logger.debug(f"Validation result: {validation_result}")

            menu_result = self.find_menu(response, menu_name) or {
                "name": menu_name,
                "path": os.path.dirname(file_path),
                "components": [],
            }
+            component_name = filename.split(".")[0]
+            # This is the name of the file which will be displayed in the UI
+            # We need to change it from snake_case to CamelCase
+
+            # first check if it's already CamelCase
+            if "_" in component_name:
+                component_name_camelcase = " ".join(
+                    word.title() for word in component_name.split("_")
+                )
+            else:
+                component_name_camelcase = component_name

            component_info = {
-                "name": filename.split(".")[0],
+                "name": "CustomComponent",
+                "output_types": [component_name_camelcase],
                "file": filename,
                "code": result_content if validation_result else "",
                "error": "" if validation_result else result_content,
            }
            menu_result["components"].append(component_info)

+            logger.debug(f"Component info: {component_info}")
            if menu_result not in response["menu"]:
                response["menu"].append(menu_result)
-
+        logger.debug(
+            "-------------------- Component menu list built --------------------"
+        )
        return response
--- 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/importing/utils.py
+++ b/src/backend/langflow/interface/importing/utils.py
@ -61,9 +61,7 @@ def import_by_type(_type: str, name: str) -> Any:

 def import_custom_component(custom_component: str) -> CustomComponent:
    """Import custom component from custom component name"""
-    return import_class(
-        f"langflow.interface.custom.custom_component.{custom_component}"
-    )
+    return import_class("langflow.interface.custom.custom_component.CustomComponent")


 def import_output_parser(output_parser: str) -> Any:
--- a/src/backend/langflow/interface/initialize/loading.py
+++ b/src/backend/langflow/interface/initialize/loading.py
@ -6,7 +6,11 @@ from langchain.agents.agent import AgentExecutor
 from langchain.agents.agent_toolkits.base import BaseToolkit
 from langchain.agents.tools import BaseTool
 from langflow.interface.initialize.llm import initialize_vertexai
-from langflow.interface.initialize.utils import handle_format_kwargs, handle_node_type
+from langflow.interface.initialize.utils import (
+    handle_format_kwargs,
+    handle_node_type,
+    handle_partial_variables,
+)

 from langflow.interface.initialize.vector_store import vecstore_initializer

@ -29,6 +33,7 @@ from langflow.utils import validate
 from langchain.chains.base import Chain
 from langchain.vectorstores.base import VectorStore
 from langchain.document_loaders.base import BaseLoader
+from langflow.utils.logger import logger


 def instantiate_class(node_type: str, base_type: str, params: Dict) -> Any:
@ -40,7 +45,7 @@ def instantiate_class(node_type: str, base_type: str, params: Dict) -> Any:
            if hasattr(custom_node, "initialize"):
                return custom_node.initialize(**params)
            return custom_node(**params)
-
+    logger.debug(f"Instantiating {node_type} of type {base_type}")
    class_object = import_by_type(_type=base_type, name=node_type)
    return instantiate_based_on_type(class_object, base_type, node_type, params)

@ -83,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":
@ -111,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()}


@ -139,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:
@ -217,6 +225,9 @@ def instantiate_agent(node_type, class_object: Type[agent_module.Agent], params:
 def instantiate_prompt(node_type, class_object, params: Dict):
    params, prompt = handle_node_type(node_type, class_object, params)
    format_kwargs = handle_format_kwargs(prompt, params)
+    # Now we'll use partial_format to format the prompt
+    if format_kwargs:
+        prompt = handle_partial_variables(prompt, format_kwargs)
    return prompt, format_kwargs


@ -250,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/utils.py
+++ b/src/backend/langflow/interface/initialize/utils.py
@ -44,6 +44,18 @@ def handle_format_kwargs(prompt, params: Dict):
    return format_kwargs


+def handle_partial_variables(prompt, format_kwargs: Dict):
+    partial_variables = format_kwargs.copy()
+    partial_variables = {
+        key: value for key, value in partial_variables.items() if value
+    }
+    # Remove handle_keys otherwise LangChain raises an error
+    partial_variables.pop("handle_keys", None)
+    if partial_variables and hasattr(prompt, "partial"):
+        return prompt.partial(**partial_variables)
+    return prompt
+
+
 def handle_variable(params: Dict, input_variable: str, format_kwargs: Dict):
    variable = params[input_variable]
    if isinstance(variable, str):
--- 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:
@ -170,6 +170,26 @@ 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
+    ):
+        import chromadb  # type: ignore
+
+        settings_params = {
+            key: params[key]
+            for key, value_ in params.items()
+            if key.startswith("chroma_server_") and value_
+        }
+        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,5 @@
-from langflow.cache.utils import memoize_dict
+from typing import Any, Dict, Tuple
+from langflow.services.cache.utils import memoize_dict
 from langflow.graph import Graph
 from langflow.utils.logger import logger

@ -15,7 +16,7 @@ def build_langchain_object_with_caching(data_graph):


@memoize_dict(maxsize=10)
-def build_sorted_vertices_with_caching(data_graph):
+def build_sorted_vertices_with_caching(data_graph) -> Tuple[Any, Dict]:
    """
    Build langchain object from data_graph.
    """
--- 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,4 +1,7 @@
-from typing import Any
+import ast
+import contextlib
+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
 from langflow.interface.custom.constants import CUSTOM_COMPONENT_SUPPORTED_TYPES
@ -28,7 +31,6 @@ from langflow.interface.retrievers.base import retriever_creator
 from langflow.interface.custom.directory_reader import DirectoryReader
 from langflow.utils.logger import logger
 from langflow.utils.util import get_base_classes
-from langflow.api.utils import merge_nested_dicts

 import re
 import warnings
@ -145,7 +147,7 @@ def add_code_field(template, raw_code, field_config):
            "dynamic": True,
            "required": True,
            "placeholder": "",
-            "show": True,
+            "show": field_config.pop("show", True),
            "multiline": True,
            "value": raw_code,
            "password": False,
@ -186,7 +188,7 @@ def build_frontend_node(custom_component: CustomComponent):
        return None


-def update_display_name_and_description(frontend_node, template_config):
+def update_attributes(frontend_node, template_config):
    """Update the display name and description of a frontend node"""
    if "display_name" in template_config:
        frontend_node["display_name"] = template_config["display_name"]
@ -194,6 +196,12 @@ def update_display_name_and_description(frontend_node, template_config):
    if "description" in template_config:
        frontend_node["description"] = template_config["description"]

+    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"""
@ -247,55 +255,60 @@ def get_field_properties(extra_field):
    if not field_required:
        field_type = extract_type_from_optional(field_type)

+    with contextlib.suppress(Exception):
+        field_value = ast.literal_eval(field_value)
    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):
    """Build a custom component template for the langchain"""
+    logger.debug("Building custom component template")
    frontend_node = build_frontend_node(custom_component)

    if frontend_node is None:
        return None
-
+    logger.debug("Built base frontend node")
    template_config = custom_component.build_template_config

-    update_display_name_and_description(frontend_node, template_config)
-
+    update_attributes(frontend_node, template_config)
+    logger.debug("Updated attributes")
    field_config = build_field_config(custom_component)
+    logger.debug("Built field config")
    add_extra_fields(
        frontend_node, field_config, custom_component.get_function_entrypoint_args
    )
-
+    logger.debug("Added extra fields")
    frontend_node = add_code_field(
        frontend_node, custom_component.code, field_config.get("code", {})
    )
-
+    logger.debug("Added code field")
    add_base_classes(
        frontend_node, custom_component.get_function_entrypoint_return_type
    )
-
+    logger.debug("Added base classes")
    return frontend_node


@ -306,7 +319,7 @@ def load_files_from_path(path: str):
    return reader.get_files()


-def build_and_validate_all_files(reader, file_list):
+def build_and_validate_all_files(reader: DirectoryReader, file_list):
    """Build and validate all files"""
    data = reader.build_component_menu_list(file_list)

@ -319,31 +332,53 @@ def build_and_validate_all_files(reader, file_list):
 def build_valid_menu(valid_components):
    """Build the valid menu"""
    valid_menu = {}
+    logger.debug("------------------- VALID COMPONENTS -------------------")
    for menu_item in valid_components["menu"]:
        menu_name = menu_item["name"]
        valid_menu[menu_name] = {}

        for component in menu_item["components"]:
+            logger.debug(f"Building component: {component}")
            try:
                component_name = component["name"]
                component_code = component["code"]
+                component_output_types = component["output_types"]

                component_extractor = CustomComponent(code=component_code)
                component_extractor.is_check_valid()
+
                component_template = build_langchain_template_custom_component(
                    component_extractor
                )
+                component_template["output_types"] = component_output_types
+                if len(component_output_types) == 1:
+                    component_name = component_output_types[0]
+                else:
+                    file_name = component.get("file").split(".")[0]
+                    if "_" in file_name:
+                        # turn .py file into camelcase
+                        component_name = "".join(
+                            [word.capitalize() for word in file_name.split("_")]
+                        )
+                    else:
+                        component_name = file_name

                valid_menu[menu_name][component_name] = component_template
+                logger.debug(f"Added {component_name} to valid menu to {menu_name}")

            except Exception as exc:
-                logger.error(f"Error while building custom component: {exc}")
+                logger.error(f"Error loading Component: {component['output_types']}")
+                logger.exception(
+                    f"Error while building custom component {component_output_types}: {exc}"
+                )

    return valid_menu


 def build_invalid_menu(invalid_components):
    """Build the invalid menu"""
+    if invalid_components.get("menu"):
+        logger.debug("------------------- INVALID COMPONENTS -------------------")
    invalid_menu = {}
    for menu_item in invalid_components["menu"]:
        menu_name = menu_item["name"]
@ -364,12 +399,16 @@ def build_invalid_menu(invalid_components):
                )

                component_template["error"] = component.get("error", None)
+                logger.debug(component)
+                logger.debug(f"Component Path: {component.get('path', None)}")
+                logger.debug(f"Component Error: {component.get('error', None)}")
                component_template.get("template").get("code")["value"] = component_code

                invalid_menu[menu_name][component_name] = component_template
+                logger.debug(f"Added {component_name} to invalid menu to {menu_name}")

            except Exception as exc:
-                logger.error(
+                logger.exception(
                    f"Error while creating custom component [{component_name}]: {str(exc)}"
                )

@ -388,4 +427,4 @@ def build_langchain_custom_component_list_from_path(path: str):
    valid_menu = build_valid_menu(valid_components)
    invalid_menu = build_invalid_menu(invalid_components)

-    return merge_nested_dicts(valid_menu, invalid_menu)
+    return merge_nested_dicts_with_renaming(valid_menu, invalid_menu)
--- 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,24 +64,21 @@ 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}")


-# TODO Rename this here and in `setup_llm_caching`
 def set_langchain_cache(settings):
    import langchain
    from langflow.interface.importing.utils import import_class

    cache_type = os.getenv("LANGFLOW_LANGCHAIN_CACHE")
-    cache_class = import_class(f"langchain.cache.{cache_type or settings.cache}")
+    cache_class = import_class(f"langchain.cache.{cache_type or settings.CACHE}")

    logger.debug(f"Setting up LLM caching with {cache_class.__name__}")
    langchain.llm_cache = cache_class()
--- 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
+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,8 +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")(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

@ -67,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/processing/base.py
+++ b/src/backend/langflow/processing/base.py
@ -5,6 +5,7 @@ from langflow.api.v1.callback import (
 )
 from langflow.processing.process import fix_memory_inputs, format_actions
 from langflow.utils.logger import logger
+from langchain.agents.agent import AgentExecutor


 async def get_result_and_steps(langchain_object, inputs: Union[dict, str], **kwargs):
@ -20,7 +21,8 @@ async def get_result_and_steps(langchain_object, inputs: Union[dict, str], **kwa
            # to display intermediate steps
            langchain_object.return_intermediate_steps = True
        try:
-            fix_memory_inputs(langchain_object)
+            if not isinstance(langchain_object, AgentExecutor):
+                fix_memory_inputs(langchain_object)
        except Exception as exc:
            logger.error(f"Error fixing memory inputs: {exc}")

--- a/src/backend/langflow/processing/process.py
+++ b/src/backend/langflow/processing/process.py
@ -85,39 +85,55 @@ def get_input_str_if_only_one_input(inputs: dict) -> Optional[str]:
    return list(inputs.values())[0] if len(inputs) == 1 else None


-def process_graph_cached(
-    data_graph: Dict[str, Any], inputs: Optional[dict] = None, clear_cache=False
-):
-    """
-    Process graph by extracting input variables and replacing ZeroShotPrompt
-    with PromptTemplate,then run the graph and return the result and thought.
-    """
-    # Load langchain object
+def get_build_result(data_graph, session_id):
+    # If session_id is provided, load the langchain_object from the session
+    # using build_sorted_vertices_with_caching.get_result_by_session_id
+    # if it returns something different than None, return it
+    # otherwise, build the graph and return the result
+    if session_id:
+        logger.debug(f"Loading LangChain object from session {session_id}")
+        result = build_sorted_vertices_with_caching.get_result_by_session_id(session_id)
+        if result is not None:
+            logger.debug("Loaded LangChain object")
+            return result
+
+    logger.debug("Building langchain object")
+    return build_sorted_vertices_with_caching(data_graph)
+
+
+def clear_caches_if_needed(clear_cache: bool):
    if clear_cache:
        build_sorted_vertices_with_caching.clear_cache()
        logger.debug("Cleared cache")
-    langchain_object, artifacts = build_sorted_vertices_with_caching(data_graph)
-    logger.debug("Loaded LangChain object")
-    if inputs is None:
-        inputs = {}

-    # Add artifacts to inputs
-    # artifacts can be documents loaded when building
-    # the flow
-    for (
-        key,
-        value,
-    ) in artifacts.items():
-        if key not in inputs or not inputs[key]:
-            inputs[key] = value
+
+def load_langchain_object(
+    data_graph: Dict[str, Any], session_id: str
+) -> Tuple[Union[Chain, VectorStore], Dict[str, Any], str]:
+    langchain_object, artifacts = get_build_result(data_graph, session_id)
+    session_id = build_sorted_vertices_with_caching.hash
+    logger.debug("Loaded LangChain object")

    if langchain_object is None:
-        # Raise user facing error
        raise ValueError(
            "There was an error loading the langchain_object. Please, check all the nodes and try again."
        )

-    # Generate result and thought
+    return langchain_object, artifacts, session_id
+
+
+def process_inputs(inputs: Optional[dict], artifacts: Dict[str, Any]) -> dict:
+    if inputs is None:
+        inputs = {}
+
+    for key, value in artifacts.items():
+        if key not in inputs or not inputs[key]:
+            inputs[key] = value
+
+    return inputs
+
+
+def generate_result(langchain_object: Union[Chain, VectorStore], inputs: dict):
    if isinstance(langchain_object, Chain):
        if inputs is None:
            raise ValueError("Inputs must be provided for a Chain")
@ -130,9 +146,28 @@ def process_graph_cached(
        raise ValueError(
            f"Unknown langchain_object type: {type(langchain_object).__name__}"
        )
+
    return result


+def process_graph_cached(
+    data_graph: Dict[str, Any],
+    inputs: Optional[dict] = None,
+    clear_cache=False,
+    session_id=None,
+) -> Tuple[Any, str]:
+    clear_caches_if_needed(clear_cache)
+    # If session_id is provided, load the langchain_object from the session
+    # else build the graph and return the result and the new session_id
+    langchain_object, artifacts, session_id = load_langchain_object(
+        data_graph, session_id
+    )
+    processed_inputs = process_inputs(inputs, artifacts)
+    result = generate_result(langchain_object, processed_inputs)
+
+    return result, session_id
+
+
 def load_flow_from_json(
    flow: Union[Path, str, dict], tweaks: Optional[dict] = None, build=True
 ):
--- 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/Show more
+++ b/Show more