@lobehub/chat 1.22.0 → 1.22.2

package/docs/self-hosting/server-database/docker-compose.mdx

@@ -1,16 +1,14 @@
 ---
-title: Deploying LobeChat Server Database with Docker Compose
-description: >-
-  Learn how to deploy LobeChat Server Database using Docker Compose, including
-  configuration tutorials for various services.
+title: Deploying LobeChat with Docker Compose
+description: Learn how to deploy the LobeChat service using Docker Compose, including configuration tutorials for various services.
 tags:
   - Docker Compose
   - LobeChat
-  - Docker Container
+  - Docker Containers
   - Deployment Guide
 ---
 
-# Deploying LobeChat server database with Docker Compose
+# Deploying LobeChat Server Database Version with Docker Compose
 
 <div style={{display:"flex", gap: 4}}>
   [![][docker-release-shield]][docker-release-link]
@@ -22,81 +20,128 @@ tags:
 </div>
 
 <Callout type="info">
-  This article assumes that you are familiar with the basic principles and processes of deploying
-  the LobeChat server database version (hereinafter referred to as DB version), so it only includes
-  the core environment variable configuration. If you are not familiar with the deployment
-  principles of LobeChat DB version, please refer to [Deploying using a Server
-  Database](/zh/docs/self-hosting/server-database).
+  This article assumes you are familiar with the basic principles and processes of deploying the
+  LobeChat server database version (hereinafter referred to as DB version), so it only includes core
+  environment variable configurations. If you are not familiar with the deployment principles of
+  LobeChat DB version, please refer to [Deploying with a Server
+  Database](/docs/self-hosting/server-database).
 </Callout>
 
 <Callout type="warning">
-  Due to the inability to expose `NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY` using Docker environment variables, you cannot use Clerk as an authentication service when deploying LobeChat using Docker / Docker Compose.
+  Due to the inability to expose `NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY` using Docker environment variables, you cannot use Clerk as a login authentication service when deploying LobeChat with Docker / Docker Compose.
 
-If you do need Clerk as an authentication service, you might consider deploying using Vercel or building your own image.
+If you need Clerk as a login authentication service, consider deploying with Vercel or building your own image.
 
 </Callout>
 
-Generally speaking, to fully run the LobeChat database version, you need at least the following four services:
+In general, to fully run the LobeChat database version, you need at least the following four services:
 
-- LobeChat database version itself
-- PostgreSQL database with PGVector plugin
-- Object storage service supporting S3 protocol
-- SSO authentication service supported by LobeChat
+- The LobeChat database version itself
+- A PostgreSQL database with the PGVector plugin
+- An object storage service that supports S3 protocol
+- An SSO login authentication service supported by LobeChat
 
-These services can be combined through self-hosting or online cloud services to meet your needs.
+These services can be combined through self-built or online cloud services to meet different levels of deployment needs.
 
-We provide a fully self-built Docker Compose configuration, which you can use directly to start the LobeChat database version or modify to suit your needs.
+In this article, we provide a Docker Compose configuration entirely based on open-source self-built services. You can use this configuration file directly to start the LobeChat database version or modify it to suit your needs.
 
-We default to using [MinIO](https://github.com/minio/minio) as the local S3 object storage service and [Logto](https://github.com/logto-io/logto) as the local authentication service.
+We default to using [MinIO](https://github.com/minio/minio) as the local S3 object storage service and [Casdoor](https://github.com/casdoor/casdoor) as the local authentication service.
 
 ## Quick Start
 
-To facilitate quick start, this chapter uses the docker-compose configuration file in the `docker-compose/local` directory. The LobeChat application runs at `http://localhost:3210` after startup and can be run locally.
+To facilitate a quick start, this section uses the `docker-compose/local` directory's `docker-compose.yml` configuration file. The started LobeChat application runs at `http://localhost:3210` and can be run locally.
 
 <Callout type="warning">
-  To facilitate quick start, this docker-compose.yml omits a large number of Secret/Password configurations and is only suitable for quick demonstration or personal local use. Do not use it directly in a production environment! Otherwise, you will be responsible for any security issues!
+  For a quick start, this `docker-compose.yml` contains a large number of sensitive Secret/Password
+  fields, suitable only for quick demonstrations or personal local use. Do not use it directly in a
+  production environment! Otherwise, you will be responsible for any security issues encountered!
 </Callout>
 
 <Steps>
-  ### Create Configuration Files
+  ### One-click Startup Script
 
-Create a new `lobe-chat-db` directory to store your configuration files and subsequent database files.
+Create a new directory named `lobe-chat-db` to store your configuration files and subsequent database files.
 
 ```sh
 mkdir lobe-chat-db
+cd lobe-chat-db
 ```
 
-Pull the configuration files into your directory:
+We provide a one-click startup script `setup.sh`, which can automatically use the default configuration and start the service:
 
 ```sh
-curl -fsSL https://raw.githubusercontent.com/lobehub/lobe-chat/HEAD/docker-compose/local-logto/docker-compose.yml > docker-compose.yml
-curl -fsSL https://raw.githubusercontent.com/lobehub/lobe-chat/HEAD/docker-compose/local-logto/.env.example > .env
+bash <(curl -fsSL https://raw.githubusercontent.com/lobehub/lobe-chat/HEAD/docker-compose/local/setup.sh) -f
 ```
 
-### Start Services
+### Start Docker
 
 ```sh
 docker compose up -d
 ```
 
-### Configure Logto
+The default login account is the default account of Casdoor, with the username `admin` and password `123`.
 
-1. Open `http://localhost:3002` to access the Logto WebUI and register an administrator account.
+### Check Logs
 
-2. Create a `Next.js (App Router)` application and add the following configurations:
+```sh
+docker logs -f lobe-chat
+```
+
+If you see the following logs in the container, it means the startup was successful:
+
+```log
+[Database] Start to migration...
+✅ database migration pass.
+-------------------------------------
+  ▲ Next.js 14.x.x
+  - Local:        http://localhost:3210
+  - Network:      http://0.0.0.0:3210
+
+ ✓ Starting...
+ ✓ Ready in 95ms
+```
+
+</Steps>
 
-   - `Redirect URI` should be `http://localhost:3210/api/auth/callback/logto`
-   - `Post sign-out redirect URI` should be `http://localhost:3210/`
+At this point, you have successfully deployed the LobeChat database version, and you can access your LobeChat service at `http://localhost:3210`.
 
-3. Obtain the `App ID` and `App secrets`, and fill them into your `.env` file corresponding to `AUTH_LOGTO_ID` and `AUTH_LOGTO_SECRET`.
+If you encounter problems, try checking the Docker logs and console logs for troubleshooting.
+
+## Publishing to Production (IP Mode)
+
+The following assumes that the machine IP running the LobeChat service on the LAN/public network is `your_server_ip`.
+
+To access via the local network IP, you first need to run the local startup:
+
+```sh
+bash <(curl -fsSL https://raw.githubusercontent.com/lobehub/lobe-chat/HEAD/docker-compose/local/setup.sh) -f
+docker compose up -d
+```
+
+Next, you need to modify the downloaded `docker-compose.yml` file, performing a global replacement to change `localhost` to `your_server_ip`, and then restart:
+
+```sh
+sed -i 's/localhost/your_server_ip/g' docker-compose.yml
+docker compose up -d
+```
+
+### Configuring Casdoor
+
+1. After starting with the `setup.sh` script, the default port for Casdoor WebUI is `8000`. You can access it via `http://your_server_ip:8000`, with the default username `admin` and password `123`.
+
+2. In `Identity -> Applications`, add a new line:
+
+   ```
+   http://your_server_ip:3210/api/auth/callback/casdoor
+   ```
 
-### Configure MinIO S3
+3. Most other configurations can remain default; you can modify the default configurations in `Identity -> Applications`.
 
-1. Open `http://localhost:9001` to access the MinIO WebUI. The default admin account password is configured in `.env`.
+### Configuring MinIO S3
 
-2. Create a bucket that matches the `MINIO_LOBE_BUCKET` field in your `.env` file, which defaults to `lobe`.
+1. After starting with the `setup.sh` script, the default port for MinIO WebUI is `9001`. You can access it via `http://your_server_ip:9001`, with the default username `YOUR_MINIO_USER` and password `YOUR_MINIO_PASSWORD`.
 
-3. Choose a custom policy, copy the following content, and paste it in (if you modified the bucket name, please find and replace accordingly):
+2. Most configurations can remain default. If you wish to allow users to change their avatars, you need to create a bucket named `casdoor` in `buckets`, select custom policy, and copy and paste the following content (if you have changed the bucket name, please find and replace):
 
    ```json
    {
@@ -107,7 +152,7 @@ docker compose up -d
            "AWS": ["*"]
          },
          "Action": ["s3:GetBucketLocation"],
-         "Resource": ["arn:aws:s3:::lobe"]
+         "Resource": ["arn:aws:s3:::casdoor"]
        },
        {
          "Effect": "Allow",
@@ -115,7 +160,7 @@ docker compose up -d
            "AWS": ["*"]
          },
          "Action": ["s3:ListBucket"],
-         "Resource": ["arn:aws:s3:::lobe"],
+         "Resource": ["arn:aws:s3:::casdoor"],
          "Condition": {
            "StringEquals": {
              "s3:prefix": ["files/*"]
@@ -128,122 +173,108 @@ docker compose up -d
            "AWS": ["*"]
          },
          "Action": ["s3:PutObject", "s3:DeleteObject", "s3:GetObject"],
-         "Resource": ["arn:aws:s3:::lobe/files/**"]
+         "Resource": ["arn:aws:s3:::casdoor/**"]
        }
      ],
      "Version": "2012-10-17"
    }
    ```
 
-4. Create a new access key, and fill the generated `Access Key` and `Secret Key` into your `.env` file under `S3_ACCESS_KEY_ID` and `S3_SECRET_ACCESS_KEY`.
+3. Create a new access key and store the generated `Access Key` and `Secret Key`.
 
-### Restart LobeChat Service
+4. In Casdoor's `Identity -> Providers`, associate the MinIO S3 service. Here is a sample configuration:
 
-```sh
-docker compose up -d
-```
+   ![casdoor](https://github.com/user-attachments/assets/71035610-0706-434e-9488-ab5819b55330)
 
-  <Callout type="warning">
-    At this point, do not use `docker compose restart lobe` to restart, as this method will not reload the environment variables, and your S3 configuration will not take effect.
- 
-</Callout>
-
-If you see the following logs in the container, it indicates that it has started successfully:
-
-```log
-[Database] Start to migration...
-✅ database migration pass.
--------------------------------------
-  ▲ Next.js 14.x.x
-  - Local:        http://localhost:3210
-  - Network:      http://0.0.0.0:3210
-
- ✓ Starting...
- ✓ Ready in 95ms
-```
+   The Client ID and Client Secret should be the `Access Key` and `Secret Key` from the previous step, and `192.168.31.251` should be replaced with `your_server_ip`.
 
-</Steps>
+5. In Casdoor's `Identity -> Applications`, add the provider to the `app-built-in` application, select `minio`, save and exit.
 
-You have successfully deployed the LobeChat database version, and you can access your LobeChat service at `http://localhost:3210`.
+6. You can try uploading a file in Casdoor's `Identity -> Resources` to test if the configuration is correct.
 
-If you encounter issues, please check the Docker logs and console logs, and follow the detailed troubleshooting guide later in the document.
+## Publishing to Production (Domain Name Mode)
 
-## Deploying to Production
+<Callout type="info">
+  For deployments with a domain name, we recommend using [Logto](https://logto.io/) as the login
+  authentication service. The remainder of this article will use it as an example. If you use other
+  authentication services like Casdoor, the process should be similar, but note that different
+  authentication services may have different port configurations.
+</Callout>
 
-The main difference between production and local operation is the need to use domain addresses instead of localhost. We assume that in addition to the above services, you are also running an Nginx layer for reverse proxy and SSL configuration.
+In the following text, we assume that in addition to the above services, you are also running a layer of Nginx for reverse proxy and SSL configuration.
 
-The domain names and corresponding service port descriptions are as follows:
+The domain and associated service port descriptions are as follows:
 
-- `lobe.example.com`: your LobeChat service domain, needs to be reverse proxied to the LobeChat service port, default is `3210`
-- `lobe-auth-api.example.com`: your Logto service domain, needs to be reverse proxied to the Logto API service port, default is `3001`
-- `lobe-auth-ui.example.com`: your Logto UI domain, needs to be reverse proxied to the Logto WebUI service port, default is `3002`
-- `lobe-s3-api.example.com`: your MinIO API domain, needs to be reverse proxied to the MinIO API service port, default is `9000`
-- `lobe-s3-ui.example.com`: optional, your MinIO UI domain, needs to be reverse proxied to the MinIO WebUI service port, default is `9001`
+- `lobe.example.com`: Your LobeChat service domain, which needs to reverse proxy to the LobeChat service port, defaulting to `3210`.
+- `lobe-auth-api.example.com`: Your Logto service domain, which needs to reverse proxy to the Logto API service port, defaulting to `3001`.
+- `lobe-auth-ui.example.com`: Your Logto UI domain, which needs to reverse proxy to the Logto WebUI service port, defaulting to `3002`.
+- `lobe-s3-api.example.com`: Your MinIO API domain, which needs to reverse proxy to the MinIO API service port, defaulting to `9000`.
+- `lobe-s3-ui.example.com`: Optional, your MinIO UI domain, which needs to reverse proxy to the MinIO WebUI service port, defaulting to `9001`.
 
-And the service port without reverse proxy:
+And the service ports that do not require reverse proxy:
 
-- `postgresql`: your PostgreSQL database service port, default is `5432`
+- `postgresql`: Your PostgreSQL database service port, defaulting to `5432`.
 
 <Callout type="warning">
-  Please note that CORS cross-origin is configured internally in MinIO / Logto service, do not configure CORS additionally in your reverse proxy, as this will cause errors.
-  For minio ports other than 443, Host must be $http_host (with port number), otherwise a 403 error will occur: proxy_set_header Host $http_host.
+  Please note that CORS cross-domain is configured internally in MinIO / Logto services. Do not configure CORS additionally in your reverse proxy, as this will cause errors.
+
+For MinIO not on port 443, the Host must be `$http_host` (with port number), otherwise a 403 error will occur: `proxy_set_header Host $http_host`.
 
-If you need to configure SSL certificates, please configure them uniformly in the outer Nginx reverse proxy, rather than in MinIO.
+If you need to configure an SSL certificate, please configure it uniformly in the outer Nginx reverse proxy and not in MinIO.
 
 </Callout>
 
 ### Configuration Files
 
 ```sh
-curl -fsSL https://raw.githubusercontent.com/lobehub/lobe-chat/HEAD/docker-compose/production/docker-compose.yml > docker-compose.yml
-curl -fsSL https://raw.githubusercontent.com/lobehub/lobe-chat/HEAD/docker-compose/production/.env.example > .env
+curl -fsSL https://raw.githubusercontent.com/lobehub/lobe-chat/HEAD/docker-compose/production/logto/docker-compose.yml > docker-compose.yml
+curl -fsSL https://raw.githubusercontent.com/lobehub/lobe-chat/HEAD/docker-compose/production/logto/.env.example > .env
 ```
 
-The configuration files include `.env` and `docker-compose.yml`, where the `.env` file is used to configure LobeChat's environment variables, and the `docker-compose.yml` file is used to configure the Postgres, MinIO, and Logto services.
+The configuration files include both `.env` and `docker-compose.yml`, where the `.env` file is used to configure the environment variables for LobeChat, and the `docker-compose.yml` file is used to configure the Postgres, MinIO, and Logto services.
 
-In general, you should only modify sensitive information such as domain names and account passwords, while other configuration items should be set according to the default values.
+Generally, you should only modify sensitive information such as domain names and account passwords, while keeping other configuration items at their default values.
 
-Refer to the example configurations in the appendix of this article.
+Refer to the appendix for example configurations.
 
-### PostgreSQL Database Configuration
+### Postgres Database Configuration
 
-You can check the logs using the following command:
+You can check the logs with the following command:
 
 ```sh
-docker logs -f lobe-database
+docker logs -f lobe-chat
 ```
 
 <Callout type="tip">
-  In our official Docker images, the database schema migration will be automatically executed before
-  starting the image. Our official image guarantees the stability of the "empty database -> complete
-  table" automatic table creation. Therefore, we recommend that your database instance use an empty
-  table instance, thereby avoiding the hassle of manually maintaining table structures or
-  migrations.
+  In our official Docker image, database schema migration is automatically executed before starting
+  the image. Our official image promises stability in the automatic creation of tables from "empty
+  database -> complete tables." Therefore, we recommend that your database instance use an empty
+  table instance to avoid the hassle of manual table structure maintenance or migration.
 </Callout>
 
-If you encounter issues when creating tables, you can try using the following commands to forcibly remove the database container and restart:
+If you encounter issues when creating tables, you can try the following command to force remove the database container and restart:
 
 ```sh
-docker compose down  # Stop services
+docker compose down  # Stop the service
 sudo rm -rf ./data   # Remove mounted database data
 docker compose up -d # Restart
 ```
 
-### Authentication Service Configuration
+### Login Authentication Service Configuration
 
 This article uses Logto as an example to explain the configuration process. If you are using other authentication service providers, please refer to their documentation for configuration.
 
 <Callout type="warning">
-  Please remember to configure the corresponding CORS cross-origin settings for the authentication service provider to ensure that LobeChat can access the authentication service properly.
+  Please remember to configure the CORS cross-domain settings for the corresponding login authentication service provider to ensure LobeChat can access the authentication service properly.
 
-In this article, you need to allow cross-origin requests from `https://lobe.example.com`.
+In this article, you need to allow cross-domain requests from `https://lobe.example.com`.
 
 </Callout>
 
-You need to first access the WebUI for configuration:
+You first need to visit the WebUI for configuration:
 
-- If you configured the reverse proxy as mentioned earlier, open `https://lobe-auth-ui.example.com`
-- Otherwise, after port mapping, open `http://localhost:3002`
+- If you have configured the reverse proxy as mentioned earlier, open `https://lobe-auth-ui.example.com`.
+- Otherwise, open `http://localhost:3002` after performing port mapping.
 
 1. Register a new account; the first registered account will automatically become an administrator.
 
@@ -254,7 +285,7 @@ You need to first access the WebUI for configuration:
 4. Set `CORS allowed origins` to `https://lobe.example.com`.
 
    <Image
-     alt="Configure Logto"
+     alt="Configuring Logto"
      src="https://github.com/user-attachments/assets/5b816379-c07b-40ea-bde4-df16e2e4e523"
    />
 
@@ -263,14 +294,14 @@ You need to first access the WebUI for configuration:
 6. Set `AUTH_LOGTO_ISSUER` in your `.env` file to `https://lobe-auth-api.example.com/oidc`.
 
    <Image
-     alt="Configure environment variables"
+     alt="Configuring Logto Environment Variables"
      src="https://github.com/user-attachments/assets/15af6d94-af4f-4aa9-bbab-7a46e9f9e837"
    />
 
-7. Optional: In the left panel under `Sign-in experience`, in `Sign-up and sign-in - Advanced Options`, disable `Enable user registration` to prohibit user self-registration. If you disable user self-registration, you can only manually add users in the left panel under `User Management`.
+7. Optionally, in the left panel under `Sign-in experience`, you can disable `Enable user registration` in `Sign-up and sign-in - Advanced Options` to prevent users from registering on their own. If you disable user registration, you will need to manually add users in the left panel under `User Management`.
 
    <Image
-     alt="Disable user registration"
+     alt="Disable User Registration"
      src="https://github.com/user-attachments/assets/6b2e6f7b-fec5-41c6-864a-a1add40f74a0"
    />
 
@@ -281,8 +312,8 @@ You need to first access the WebUI for configuration:
    ```
 
 <Callout type="warning">
-  Please note that the administrator account is not the same as a registered user; do not use your
-  administrator account to log into LobeChat, as this will only result in an error.
+  Please note that the administrator account is not the same as a registered user. Do not log in to
+  LobeChat with your administrator account, as this will only result in an error.
 </Callout>
 
 ### S3 Object Storage Service Configuration
@@ -290,44 +321,44 @@ You need to first access the WebUI for configuration:
 This article uses MinIO as an example to explain the configuration process. If you are using other S3 service providers, please refer to their documentation for configuration.
 
 <Callout type="warning">
-  Please remember to configure the corresponding CORS cross-origin settings for the S3 service provider to ensure that LobeChat can access the S3 service properly.
+  Please remember to configure the CORS cross-domain settings for the corresponding S3 service provider to ensure LobeChat can access the S3 service properly.
 
-In this article, you need to allow cross-origin requests from `https://lobe.example.com`. This can be configured in the MinIO WebUI under `Configuration - API - Cors Allow Origin`, or in the Docker Compose under `minio - environment - MINIO_API_CORS_ALLOW_ORIGIN`.
+In this article, you need to allow cross-domain requests from `https://lobe.example.com`. This can be configured in MinIO WebUI under `Configuration - API - Cors Allow Origin`, or in the Docker Compose under `minio - environment - MINIO_API_CORS_ALLOW_ORIGIN`.
 
-If you configure using the second method (which is also the default method), you will not be able to configure it in the MinIO WebUI anymore.
+If you use the second method (which is also the default method) for configuration, you will not be able to configure it in MinIO WebUI anymore.
 
 </Callout>
 
-You need to first access the WebUI for configuration:
+You first need to visit the WebUI for configuration:
 
-- If you configured the reverse proxy as mentioned earlier, open `https://lobe-s3-ui.example.com`
-- Otherwise, after port mapping, open `http://localhost:9001`
+- If you have configured the reverse proxy as mentioned earlier, open `https://lobe-s3-ui.example.com`.
+- Otherwise, open `http://localhost:9001` after performing port mapping.
 
-1. Enter your `MINIO_ROOT_USER` and `MINIO_ROOT_PASSWORD` on the login screen, then click login.
+1. Enter your set `MINIO_ROOT_USER` and `MINIO_ROOT_PASSWORD` on the login page, then click login.
 
-2. In the left panel under Administer / Buckets, click `Create Bucket`, enter `lobe` (corresponding to your `S3_BUCKET` environment variable), and then click `Create`.
+2. In the left panel under Administer / Buckets, click `Create Bucket`, enter `lobe` (which corresponds to your `S3_BUCKET` environment variable), and then click `Create`.
 
    <Image
-     alt="Create a bucket"
+     alt="Create MinIO Bucket"
      src="https://github.com/user-attachments/assets/79f44a13-00d3-4302-a6bc-5f4c6cdbffab"
    />
 
-3. Select your bucket, click Summary - Access Policy, edit, choose `Custom`, and input the content from `minio-bucket-config.json` (see appendix) and save (again, assuming your bucket name is `lobe`):
+3. Select your bucket, click Summary - Access Policy, edit, choose `Custom`, input the content from `minio-bucket-config.json` (see appendix), and save (assuming your bucket name is `lobe`):
 
    <Image
-     alt="Select MinIO bucket policy"
+     alt="Select MinIO Bucket Policy"
      src="https://github.com/user-attachments/assets/57032a82-7604-45d3-ba12-884af6fbcb7c"
    />
 
    <Image
-     alt="Configure MinIO bucket policy"
+     alt="Configure MinIO Bucket Policy"
      src="https://github.com/user-attachments/assets/d8109f4e-71fc-4ba8-8402-ede92669d5e0"
    />
 
-4. In the left panel under User / Access Keys, click `Create New Access Key`, make no additional modifications, and fill the generated `Access Key` and `Secret Key` into your `.env` file under `S3_ACCESS_KEY_ID` and `S3_SECRET_ACCESS_KEY`.
+4. In the left panel under User / Access Keys, click `Create New Access Key`, without any extra modifications, and fill the generated `Access Key` and `Secret Key` into your `.env` file under `S3_ACCESS_KEY_ID` and `S3_SECRET_ACCESS_KEY`.
 
    <Image
-     alt="Create a new access key"
+     alt="Create MinIO Access Key"
      src="https://github.com/user-attachments/assets/72f02ce5-9991-425b-9864-9113ee1ed6bf"
    />
 
@@ -337,161 +368,13 @@ You need to first access the WebUI for configuration:
    docker compose up -d
    ```
 
-You have successfully deployed the LobeChat database version, and you can access your LobeChat service at `https://lobe.example.com`.
+At this point, you have successfully deployed the LobeChat database version, and you can access your LobeChat service at `https://lobe.example.com`.
 
 ## Appendix
 
-To facilitate one-click copying, here are the example configuration files needed to configure the server database:
+For convenience, here is a summary of the example configuration files needed for deploying the server database in domain name mode (for local quick start, local IP access, etc., please directly use the `setup.sh` script to generate and modify it yourself):
 
-### Local Deployment
-
-#### `.env`
-
-```sh
-# Logto secret
-AUTH_LOGTO_ID=
-AUTH_LOGTO_SECRET=
-
-# MinIO S3 configuration
-MINIO_ROOT_USER=YOUR_MINIO_USER
-MINIO_ROOT_PASSWORD=YOUR_MINIO_PASSWORD
-
-# Configure the bucket information of MinIO
-MINIO_LOBE_BUCKET=lobe
-S3_ACCESS_KEY_ID=
-S3_SECRET_ACCESS_KEY=
-
-# Proxy, if you need it
-# HTTP_PROXY=http://localhost:7890
-# HTTPS_PROXY=http://localhost:7890
-
-# Other environment variables, as needed. You can refer to the environment variables configuration for the client version, making sure not to have ACCESS_CODE.
-# OPENAI_API_KEY=sk-xxxx
-# OPENAI_PROXY_URL=https://api.openai.com/v1
-# OPENAI_MODEL_LIST=...
-
-# ----- Other config -----
-# if no special requirements, no need to change
-LOBE_PORT=3210
-LOGTO_PORT=3001
-MINIO_PORT=9000
-
-# Postgres related, which are the necessary environment variables for DB
-LOBE_DB_NAME=lobechat
-POSTGRES_PASSWORD=uWNZugjBqixf8dxC
-
-```
-
-#### `docker-compose.yml`
-
-```yaml
-services:
-  network-service:
-    image: alpine
-    container_name: lobe-network
-    ports:
-      - '${MINIO_PORT}:${MINIO_PORT}'  # MinIO API
-      - '9001:9001'  # MinIO Console
-      - '${LOGTO_PORT}:${LOGTO_PORT}' # Logto
-      - '3002:3002'  # Logto Admin
-      - '${LOBE_PORT}:3210' # LobeChat
-    command: tail -f /dev/null
-    networks:
-      - lobe-network
-
-  postgresql:
-    image: pgvector/pgvector:pg16
-    container_name: lobe-postgres
-    ports:
-      - "5432:5432"
-    volumes:
-      - './data:/var/lib/postgresql/data'
-    environment:
-      - 'POSTGRES_DB=${LOBE_DB_NAME}'
-      - 'POSTGRES_PASSWORD=${POSTGRES_PASSWORD}'
-    healthcheck:
-      test: ['CMD-SHELL', 'pg_isready -U postgres']
-      interval: 5s
-      timeout: 5s
-      retries: 5
-    restart: always
-    networks:
-      - lobe-network
-
-  minio:
-    image: minio/minio
-    container_name: lobe-minio
-    network_mode: 'service:network-service'
-    volumes:
-      - './s3_data:/etc/minio/data'
-    environment:
-      - 'MINIO_ROOT_USER=${MINIO_ROOT_USER}'
-      - 'MINIO_ROOT_PASSWORD=${MINIO_ROOT_PASSWORD}'
-      - 'MINIO_API_CORS_ALLOW_ORIGIN=http://localhost:${LOBE_PORT}'
-    restart: always
-    command: >
-      server /etc/minio/data --address ":${MINIO_PORT}" --console-address ":9001"
-
-  logto:
-    image: svhd/logto
-    container_name: lobe-logto
-    network_mode: 'service:network-service'
-    depends_on:
-      postgresql:
-        condition: service_healthy
-    environment:
-      - 'TRUST_PROXY_HEADER=1'
-      - 'PORT=${LOGTO_PORT}'
-      - 'DB_URL=postgresql://postgres:${POSTGRES_PASSWORD}@postgresql:5432/logto'
-      - 'ENDPOINT=http://localhost:${LOGTO_PORT}'
-      - 'ADMIN_ENDPOINT=http://localhost:3002'
-    entrypoint: ['sh', '-c', 'npm run cli db seed -- --swe && npm start']
-
-  lobe:
-    image: lobehub/lobe-chat-database
-    container_name: lobe-database
-    network_mode: 'service:network-service'
-    depends_on:
-      postgresql:
-        condition: service_healthy
-      network-service:
-        condition: service_started
-      minio:
-        condition: service_started
-      logto:
-        condition: service_started
-
-    environment:
-      - 'APP_URL=http://localhost:3210'
-      - 'NEXT_AUTH_SSO_PROVIDERS=logto'
-      - 'KEY_VAULTS_SECRET=Kix2wcUONd4CX51E/ZPAd36BqM4wzJgKjPtz2sGztqQ='
-      - 'NEXT_AUTH_SECRET=NX2kaPE923dt6BL2U8e9oSre5RfoT7hg'
-      - 'NEXTAUTH_URL=http://localhost:${LOBE_PORT}/api/auth'
-      - 'AUTH_LOGTO_ISSUER=http://localhost:${LOGTO_PORT}/oidc'
-      - 'DATABASE_URL=postgresql://postgres:${POSTGRES_PASSWORD}@postgresql:5432/${LOBE_DB_NAME}'
-      - 'S3_ENDPOINT=http://localhost:${MINIO_PORT}'
-      - 'S3_BUCKET=${MINIO_LOBE_BUCKET}'
-      - 'S3_PUBLIC_DOMAIN=http://localhost:${MINIO_PORT}'
-      - 'S3_ENABLE_PATH_STYLE=1'
-    env_file:
-      - .env
-    restart: always
-
-volumes:
-  data:
-    driver: local
-  s3_data:
-    driver: local
-
-networks:
-  lobe-network:
-    driver: bridge
-
-```
-
-### Deploying to Production
-
-#### `.env`
+### `.env`
 
 ```sh
 # Required: LobeChat domain for tRPC calls
@@ -519,8 +402,8 @@ NEXTAUTH_URL=https://lobe.example.com/api/auth
 
 # NextAuth providers configuration (example using Logto)
 # For other providers, see: https://lobehub.com/docs/self-hosting/environment-variables/auth
-AUTH_LOGTO_ID=YOUR_LOGTO_CLIENT_ID
-AUTH_LOGTO_SECRET=YOUR_LOGTO_CLIENT_SECRET
+AUTH_LOGTO_CLIENT_ID=YOUR_LOGTO_CLIENT_ID
+AUTH_LOGTO_CLIENT_SECRET=YOUR_LOGTO_CLIENT_SECRET
 AUTH_LOGTO_ISSUER=https://lobe-auth-api.example.com/oidc
 
 # Proxy settings (if needed, e.g., when using GitHub as an auth provider)
@@ -550,12 +433,12 @@ S3_ENABLE_PATH_STYLE=1
 # OPENAI_API_KEY=sk-xxxx
 # OPENAI_PROXY_URL=https://api.openai.com/v1
 # OPENAI_MODEL_LIST=...
-
 ```
 
-#### `docker-compose.yml`
+### `docker-compose.yml`
 
 ```yaml
+name: lobe-chat-database
 services:
   postgresql:
     image: pgvector/pgvector:pg16
@@ -591,6 +474,7 @@ services:
     command: >
       server /etc/minio/data --address ":9000" --console-address ":9001"
 
+
   logto:
     image: svhd/logto
     container_name: lobe-logto
@@ -609,7 +493,7 @@ services:
 
   lobe:
     image: lobehub/lobe-chat-database
-    container_name: lobe-database
+    container_name: lobe-chat
     ports:
       - '3210:3210'
     depends_on:
@@ -625,10 +509,9 @@ volumes:
     driver: local
   s3_data:
     driver: local
-
 ```
 
-#### `minio-bucket-config.json`
+### `minio-bucket-config.json`
 
 ```json
 {