@lobehub/lobehub 2.1.1 → 2.1.3

package/docs/self-hosting/advanced/redis.zh-CN.mdx

@@ -1,6 +1,6 @@
 ---
 title: 配置 Redis 缓存服务
-description: 了解如何配置 Redis 缓存服务以优化 LobeChat 的性能和会话管理。
+description: 了解如何配置 Redis 缓存服务以优化 LobeHub 的性能和会话管理。
 tags:
   - Redis
   - 缓存
@@ -10,17 +10,17 @@ tags:
 
 # 配置 Redis 缓存服务
 
-LobeChat 使用 Redis 作为高性能缓存和会话存储服务，用于优化系统性能和管理用户认证状态。
+LobeHub 使用 Redis 作为高性能缓存和会话存储服务，用于优化系统性能和管理用户认证状态。
 
 <Callout type={'info'}>
-  LobeChat 使用标准 Redis 协议（通过 ioredis 库），支持任何兼容 Redis 协议的服务，包括 Redis
+  LobeHub 使用标准 Redis 协议（通过 ioredis 库），支持任何兼容 Redis 协议的服务，包括 Redis
   官方服务、自部署 Redis、以及云服务商提供的 Redis 服务（如 AWS ElastiCache、阿里云 Redis
   等）。
 </Callout>
 
 ## 使用场景
 
-Redis 在 LobeChat 中主要用于以下场景：
+Redis 在 LobeHub 中主要用于以下场景：
 
 ### 认证会话存储
 
@@ -57,7 +57,7 @@ Redis 在 LobeChat 中主要用于以下场景：
 
   ### `REDIS_PREFIX`
 
-  Redis 键的前缀，用于在共享 Redis 实例中隔离 LobeChat 的数据。
+  Redis 键的前缀，用于在共享 Redis 实例中隔离 LobeHub 的数据。
 
   - 默认值：`lobechat`
   - 示例：`REDIS_PREFIX=my-lobechat`
@@ -118,7 +118,7 @@ REDIS_PREFIX=lobechat
 ## 注意事项
 
 <Callout type={'warning'}>
-  Redis 是可选服务。如果不配置 `REDIS_URL`，LobeChat 仍然可以正常运行，但会失去上述缓存和会话管理的优化功能。
+  Redis 是可选服务。如果不配置 `REDIS_URL`，LobeHub 仍然可以正常运行，但会失去上述缓存和会话管理的优化功能。
 </Callout>
 
 - **内存管理**：Redis 是内存数据库，请确保服务器有足够的内存

package/docs/self-hosting/advanced/s3/rustfs.mdx

@@ -12,131 +12,131 @@ tags:
 We need to configure an S3-compatible storage service in the server-side database to store files.
 
 <Callout type={'info'}>
-Due to recent changes in MinIO's commercial strategy, we no longer recommend MinIO as the S3 storage backend. Please migrate to open-source solutions such as [RustFS](https://rustfs.com/) or [ceph](https://ceph.io/), or to cloud providers like Tencent Cloud Object Storage or Cloudflare R2.
+  Due to recent changes in MinIO's commercial strategy, we no longer recommend MinIO as the S3 storage backend. Please migrate to open-source solutions such as [RustFS](https://rustfs.com/) or [ceph](https://ceph.io/), or to cloud providers like Tencent Cloud Object Storage or Cloudflare R2.
 </Callout>
 
 ## Configuration Steps
 
 <Steps>
-### Deploy RustFS
-
-First, pull the RustFS Docker image:
-
-```shell
-docker pull rustfs/rustfs:latest
-```
-
-You can inspect its version with the following command. We recommend version v1.0.0 or above:
-
-```shell
-docker inspect --format='{{index .Config.Labels "version"}}' rustfs/rustfs:latest
-```
-
-We recommend using Docker Compose to deploy RustFS:
-
-```yml
-services:
-    rustfs:
-        image: rustfs/rustfs:latest
-        container_name: lobe-rustfs
-        ports:
-            - '9000:9000'
-            - '9001:9001'
-        environment:
-            - RUSTFS_CONSOLE_ENABLE=true
-            - RUSTFS_ACCESS_KEY=<YOUR_ACCESS_KEY>
-            - RUSTFS_SECRET_KEY=<YOUR_SECRET_KEY>
-        volumes:
-            - rustfs-data:/data
-
-volumes:
-  rustfs-data:
-```
-
-Then start RustFS:
-
-```shell
-docker compose up -d
-```
-
-### Create a Bucket
-
-Open the RustFS WebUI (`http://localhost:9001/`) and you will be redirected to the login screen. Enter the username (`RUSTFS_ACCESS_KEY` in the `docker-compose.yml`) and password (`RUSTFS_SECRET_KEY` in the same file) to sign in.
-
-Click `Object Storage` in the left sidebar, then the `Create Bucket` button in the top-right corner to create a new bucket. This example uses the name `lobe`. Leave Versioning and Object Lock disabled (default settings).
-
-<Image alt={"Create Bucket"} src={'https://github.com/user-attachments/assets/27c37617-a813-4de5-b0bf-c7167999c856'} />
-
-Go to the bucket and click `Settings`, choose `Custom` for the policy, and paste the following JSON to make the bucket public-read/private-write:
-
-```json
-{ 
-  "ID": "", 
-  "Version": "2012-10-17", 
-  "Statement": [ 
-    { 
-      "Sid": "", 
-      "Effect": "Allow", 
-      "Principal": { 
-        "AWS": [ 
-          "*" 
-        ] 
-      }, 
-      "Action": [ 
-        "s3:GetObject" 
-      ], 
-      "NotAction": [], 
-      "Resource": [ 
-        "arn:aws:s3:::lobe/*" 
-      ], 
-      "NotResource": [], 
-      "Condition": {} 
-    } 
-  ] 
-}
-```
-
-Save the settings to apply the policy.
-
-### Configure Access Keys
-
-<Callout type={'warning'}>
-You can reuse the `RUSTFS_ACCESS_KEY` and `RUSTFS_SECRET_KEY` defined in the `docker-compose.yml`, but for better security we recommend creating a dedicated access key.
-</Callout>
-
-Click `Access Key` in the left sidebar, then `Add Access Key` to create a new key. The name is arbitrary, and you can keep the default main-account policy.
-
-Copy the generated Access Key and Secret Key (the `Export` button lets you save the JSON locally). The English labels in the UI are confusing, but remember the shorter string is the Access Key and the longer string is the Secret Key (the exported JSON is correct).
-
-<Image alt={"Add Key"} src={'https://github.com/user-attachments/assets/81f18b20-3918-4f77-8571-07d0c4a79aec'} />
-
-<Image alt={"Export Key"} src={'https://github.com/user-attachments/assets/4dde41ec-985b-4781-8c77-aac65555a32f'} />
-
-### Configure Reverse Proxy
+  ### Deploy RustFS
 
-You also need reverse-proxy rules so that RustFS is accessible from the LAN/public internet. Map the following ports to domains:
+  First, pull the RustFS Docker image:
 
-| Domain                       | Port   | Required |
-| ---------------------------- | ------ | -------- |
-| `lobe-s3-api.example.com`    | `9000` | Yes      |
-| `lobe-s3-ui.example.com`     | `9001` |          |
+  ```shell
+  docker pull rustfs/rustfs:latest
+  ```
 
-After completing the reverse proxy, remember to configure the corresponding SSL certificate and enable HTTPS access.
+  You can inspect its version with the following command. We recommend version v1.0.0 or above:
 
-### Set Environment Variables
+  ```shell
+  docker inspect --format='{{index .Config.Labels "version"}}' rustfs/rustfs:latest
+  ```
 
-Update the LobeChat `.env` file with the following environment variables to use RustFS as the S3 backend:
+  We recommend using Docker Compose to deploy RustFS:
 
-```shell
-# RustFS Access Key / Secret Key
-S3_ACCESS_KEY_ID=<YOUR_ACCESS_KEY>
-S3_SECRET_ACCESS_KEY=<YOUR_SECRET_KEY>
-# RustFS API endpoint
-S3_ENDPOINT=https://lobe-s3-api.example.com
-# Bucket name
-S3_BUCKET=lobe
-# Public domain for accessing the bucket
-S3_PUBLIC_DOMAIN=https://lobe-s3-api.example.com
-S3_ENABLE_PATH_STYLE=1
-```
+  ```yml
+  services:
+      rustfs:
+          image: rustfs/rustfs:latest
+          container_name: lobe-rustfs
+          ports:
+              - '9000:9000'
+              - '9001:9001'
+          environment:
+              - RUSTFS_CONSOLE_ENABLE=true
+              - RUSTFS_ACCESS_KEY=<YOUR_ACCESS_KEY>
+              - RUSTFS_SECRET_KEY=<YOUR_SECRET_KEY>
+          volumes:
+              - rustfs-data:/data
+
+  volumes:
+    rustfs-data:
+  ```
+
+  Then start RustFS:
+
+  ```shell
+  docker compose up -d
+  ```
+
+  ### Create a Bucket
+
+  Open the RustFS WebUI (`http://localhost:9001/`) and you will be redirected to the login screen. Enter the username (`RUSTFS_ACCESS_KEY` in the `docker-compose.yml`) and password (`RUSTFS_SECRET_KEY` in the same file) to sign in.
+
+  Click `Object Storage` in the left sidebar, then the `Create Bucket` button in the top-right corner to create a new bucket. This example uses the name `lobe`. Leave Versioning and Object Lock disabled (default settings).
+
+  <Image alt={"Create Bucket"} src={'https://github.com/user-attachments/assets/27c37617-a813-4de5-b0bf-c7167999c856'} />
+
+  Go to the bucket and click `Settings`, choose `Custom` for the policy, and paste the following JSON to make the bucket public-read/private-write:
+
+  ```json
+  {
+    "ID": "",
+    "Version": "2012-10-17",
+    "Statement": [
+      {
+        "Sid": "",
+        "Effect": "Allow",
+        "Principal": {
+          "AWS": [
+            "*"
+          ]
+        },
+        "Action": [
+          "s3:GetObject"
+        ],
+        "NotAction": [],
+        "Resource": [
+          "arn:aws:s3:::lobe/*"
+        ],
+        "NotResource": [],
+        "Condition": {}
+      }
+    ]
+  }
+  ```
+
+  Save the settings to apply the policy.
+
+  ### Configure Access Keys
+
+  <Callout type={'warning'}>
+    You can reuse the `RUSTFS_ACCESS_KEY` and `RUSTFS_SECRET_KEY` defined in the `docker-compose.yml`, but for better security we recommend creating a dedicated access key.
+  </Callout>
+
+  Click `Access Key` in the left sidebar, then `Add Access Key` to create a new key. The name is arbitrary, and you can keep the default main-account policy.
+
+  Copy the generated Access Key and Secret Key (the `Export` button lets you save the JSON locally). The English labels in the UI are confusing, but remember the shorter string is the Access Key and the longer string is the Secret Key (the exported JSON is correct).
+
+  <Image alt={"Add Key"} src={'https://github.com/user-attachments/assets/81f18b20-3918-4f77-8571-07d0c4a79aec'} />
+
+  <Image alt={"Export Key"} src={'https://github.com/user-attachments/assets/4dde41ec-985b-4781-8c77-aac65555a32f'} />
+
+  ### Configure Reverse Proxy
+
+  You also need reverse-proxy rules so that RustFS is accessible from the LAN/public internet. Map the following ports to domains:
+
+  | Domain                    | Port   | Required |
+  | ------------------------- | ------ | -------- |
+  | `lobe-s3-api.example.com` | `9000` | Yes      |
+  | `lobe-s3-ui.example.com`  | `9001` |          |
+
+  After completing the reverse proxy, remember to configure the corresponding SSL certificate and enable HTTPS access.
+
+  ### Set Environment Variables
+
+  Update the LobeHub `.env` file with the following environment variables to use RustFS as the S3 backend:
+
+  ```shell
+  # RustFS Access Key / Secret Key
+  S3_ACCESS_KEY_ID=<YOUR_ACCESS_KEY>
+  S3_SECRET_ACCESS_KEY=<YOUR_SECRET_KEY>
+  # RustFS API endpoint
+  S3_ENDPOINT=https://lobe-s3-api.example.com
+  # Bucket name
+  S3_BUCKET=lobe
+  # Public domain for accessing the bucket
+  S3_PUBLIC_DOMAIN=https://lobe-s3-api.example.com
+  S3_ENABLE_PATH_STYLE=1
+  ```
 </Steps>

package/docs/self-hosting/advanced/s3/rustfs.zh-CN.mdx

@@ -11,133 +11,132 @@ tags:
 
 在服务端数据库中我们需要配置 S3 存储服务来存储文件。
 
-
 <Callout type={'info'}>
-由于近期 MinIO 的商业化策略调整，我们不再推荐使用 MinIO 作为 S3 存储服务，建议所有仍在使用 MinIO 的用户迁移至 [RustFS](https://rustfs.com/) 或者 [ceph](https://ceph.io/) 等开源的 S3 存储服务或者腾讯云对象存储、Cloudflare R2 等云服务商的 S3 存储服务。
+  由于近期 MinIO 的商业化策略调整，我们不再推荐使用 MinIO 作为 S3 存储服务，建议所有仍在使用 MinIO 的用户迁移至 [RustFS](https://rustfs.com/) 或者 [ceph](https://ceph.io/) 等开源的 S3 存储服务或者腾讯云对象存储、Cloudflare R2 等云服务商的 S3 存储服务。
 </Callout>
 
 ## 配置步骤
 
 <Steps>
-### 部署 RustFS
-
-首先，拉取 RustFS 的 Docker 镜像：
-
-```shell
-docker pull rustfs/rustfs:latest
-```
-
-你可以使用如下命令来查看其版本，建议使用 v1.0.0 及以上版本：
-
-```shell
-docker inspect --format='{{index .Config.Labels "version"}}' rustfs/rustfs:latest
-```
-
-我们推荐使用 Docker Compose 来部署 RustFS：
-
-```yml
-services:
-    rustfs:
-        image: rustfs/rustfs:latest
-        container_name: lobe-rustfs
-        ports:
-            - '9000:9000'
-            - '9001:9001'
-        environment:
-            - RUSTFS_CONSOLE_ENABLE=true
-            - RUSTFS_ACCESS_KEY=<YOUR_ACCESS_KEY>
-            - RUSTFS_SECRET_KEY=<YOUR_SECRET_KEY>
-        volumes:
-            - rustfs-data:/data
-
-volumes:
-  rustfs-data:
-```
-
-然后，启动 RustFS：
-
-```shell
-docker compose up -d
-```
-
-### 创建存储桶
-
-访问 RustFS 的 WebUI（`http://localhost:9001/`），即可自动跳转到登录页。输入账号（上述 `docker-compose.yml` 文件中的 `RUSTFS_ACCESS_KEY`）、密码（上述 `docker-compose.yml` 文件中的 `RUSTFS_SECRET_KEY`），即可登录。
-
-点击左侧边栏的 `对象存储` 菜单，右上角 `创建存储桶` 按钮，创建一个新的存储桶（Bucket）。创建存储桶时将指定其名称，下文以 `lobe` 为例。版本、对象锁依照默认配置不开启。
-
-<Image alt={"Create Bucket"} src={'https://github.com/user-attachments/assets/27c37617-a813-4de5-b0bf-c7167999c856'} />
-
-点击存储桶 - `配置` 按钮，选择策略为 `自定义`，然后填入如下 JSON，设置存储桶的权限为 `公有读私有写`：
-
-```json
-{ 
-  "ID": "", 
-  "Version": "2012-10-17", 
-  "Statement": [ 
-    { 
-      "Sid": "", 
-      "Effect": "Allow", 
-      "Principal": { 
-        "AWS": [ 
-          "*" 
-        ] 
-      }, 
-      "Action": [ 
-        "s3:GetObject" 
-      ], 
-      "NotAction": [], 
-      "Resource": [ 
-        "arn:aws:s3:::lobe/*" 
-      ], 
-      "NotResource": [], 
-      "Condition": {} 
-    } 
-  ] 
-}
-```
-
-点击保存即可。
-
-### 设置访问密钥
-
-<Callout type={'warning'}>
-  有关这部分，你可以直接使用在 `docker-compose.yml` 文件中配置的 `RUSTFS_ACCESS_KEY` 和 `RUSTFS_SECRET_KEY`，但出于安全考虑，我们推荐你手动创建一个访问密钥。
-</Callout>
-
-点击左侧边栏的 `访问密钥` 菜单，右上角 `添加访问密钥` 按钮，创建一个新的访问密钥（Access Key）。名称随意，按照默认配置使用主账号策略即可。
-
-记录好得到的访问密钥和密钥（你可以点击 `导出` 按钮以在本地保存）。这里 RustFS 的翻译有点迷惑，但你只需要记住上面那个短的是 `Access Key`，长的是 `Secret Key` 即可（导出的 JSON 中是对的）。
-
-<Image alt={"Add Key"} src={'https://github.com/user-attachments/assets/81f18b20-3918-4f77-8571-07d0c4a79aec'} />
-
-<Image alt={"Export Key"} src={'https://github.com/user-attachments/assets/4dde41ec-985b-4781-8c77-aac65555a32f'} />
-
-### 配置反向代理
+  ### 部署 RustFS
 
-你还需要完成反向代理配置，并确保局域网 / 公网能访问到 RustFS 的服务。请使用反向代理将以下服务端口映射到域名：
+  首先，拉取 RustFS 的 Docker 镜像：
 
-| 域名                     | 反代端口   | 是否必选 |
-| ---------------------- | ------ | ---- |
-| `lobe-s3-api.example.com`     | `9000` | 必选   |
-| `lobe-s3-ui.example.com` | `9001` |      |
+  ```shell
+  docker pull rustfs/rustfs:latest
+  ```
 
-完成反向代理后，记得配置对应的 SSL 证书，启用 HTTPS 访问。
+  你可以使用如下命令来查看其版本，建议使用 v1.0.0 及以上版本：
 
-### 设置环境变量
+  ```shell
+  docker inspect --format='{{index .Config.Labels "version"}}' rustfs/rustfs:latest
+  ```
 
-修改 LobeChat 的 `.env` 文件，添加如下环境变量，即可完成配置，使用 RustFS 作为 S3 存储服务：
+  我们推荐使用 Docker Compose 来部署 RustFS：
 
-```shell
-# RustFS 的鉴权 Access Key / Secret Key
-S3_ACCESS_KEY_ID=<YOUR_ACCESS_KEY>
-S3_SECRET_ACCESS_KEY=<YOUR_SECRET_KEY>
-# RustFS API 的请求端点
-S3_ENDPOINT=https://lobe-s3-api.example.com
-# 存储桶的名称
-S3_BUCKET=lobe
-# 存储桶对外的访问域名
-S3_PUBLIC_DOMAIN=https://lobe-s3-api.example.com
-S3_ENABLE_PATH_STYLE=1
-```
+  ```yml
+  services:
+      rustfs:
+          image: rustfs/rustfs:latest
+          container_name: lobe-rustfs
+          ports:
+              - '9000:9000'
+              - '9001:9001'
+          environment:
+              - RUSTFS_CONSOLE_ENABLE=true
+              - RUSTFS_ACCESS_KEY=<YOUR_ACCESS_KEY>
+              - RUSTFS_SECRET_KEY=<YOUR_SECRET_KEY>
+          volumes:
+              - rustfs-data:/data
+
+  volumes:
+    rustfs-data:
+  ```
+
+  然后，启动 RustFS：
+
+  ```shell
+  docker compose up -d
+  ```
+
+  ### 创建存储桶
+
+  访问 RustFS 的 WebUI（`http://localhost:9001/`），即可自动跳转到登录页。输入账号（上述 `docker-compose.yml` 文件中的 `RUSTFS_ACCESS_KEY`）、密码（上述 `docker-compose.yml` 文件中的 `RUSTFS_SECRET_KEY`），即可登录。
+
+  点击左侧边栏的 `对象存储` 菜单，右上角 `创建存储桶` 按钮，创建一个新的存储桶（Bucket）。创建存储桶时将指定其名称，下文以 `lobe` 为例。版本、对象锁依照默认配置不开启。
+
+  <Image alt={"Create Bucket"} src={'https://github.com/user-attachments/assets/27c37617-a813-4de5-b0bf-c7167999c856'} />
+
+  点击存储桶 - `配置` 按钮，选择策略为 `自定义`，然后填入如下 JSON，设置存储桶的权限为 `公有读私有写`：
+
+  ```json
+  {
+    "ID": "",
+    "Version": "2012-10-17",
+    "Statement": [
+      {
+        "Sid": "",
+        "Effect": "Allow",
+        "Principal": {
+          "AWS": [
+            "*"
+          ]
+        },
+        "Action": [
+          "s3:GetObject"
+        ],
+        "NotAction": [],
+        "Resource": [
+          "arn:aws:s3:::lobe/*"
+        ],
+        "NotResource": [],
+        "Condition": {}
+      }
+    ]
+  }
+  ```
+
+  点击保存即可。
+
+  ### 设置访问密钥
+
+  <Callout type={'warning'}>
+    有关这部分，你可以直接使用在 `docker-compose.yml` 文件中配置的 `RUSTFS_ACCESS_KEY` 和 `RUSTFS_SECRET_KEY`，但出于安全考虑，我们推荐你手动创建一个访问密钥。
+  </Callout>
+
+  点击左侧边栏的 `访问密钥` 菜单，右上角 `添加访问密钥` 按钮，创建一个新的访问密钥（Access Key）。名称随意，按照默认配置使用主账号策略即可。
+
+  记录好得到的访问密钥和密钥（你可以点击 `导出` 按钮以在本地保存）。这里 RustFS 的翻译有点迷惑，但你只需要记住上面那个短的是 `Access Key`，长的是 `Secret Key` 即可（导出的 JSON 中是对的）。
+
+  <Image alt={"Add Key"} src={'https://github.com/user-attachments/assets/81f18b20-3918-4f77-8571-07d0c4a79aec'} />
+
+  <Image alt={"Export Key"} src={'https://github.com/user-attachments/assets/4dde41ec-985b-4781-8c77-aac65555a32f'} />
+
+  ### 配置反向代理
+
+  你还需要完成反向代理配置，并确保局域网 / 公网能访问到 RustFS 的服务。请使用反向代理将以下服务端口映射到域名：
+
+  | 域名                        | 反代端口   | 是否必选 |
+  | ------------------------- | ------ | ---- |
+  | `lobe-s3-api.example.com` | `9000` | 必选   |
+  | `lobe-s3-ui.example.com`  | `9001` |      |
+
+  完成反向代理后，记得配置对应的 SSL 证书，启用 HTTPS 访问。
+
+  ### 设置环境变量
+
+  修改 LobeHub 的 `.env` 文件，添加如下环境变量，即可完成配置，使用 RustFS 作为 S3 存储服务：
+
+  ```shell
+  # RustFS 的鉴权 Access Key / Secret Key
+  S3_ACCESS_KEY_ID=<YOUR_ACCESS_KEY>
+  S3_SECRET_ACCESS_KEY=<YOUR_SECRET_KEY>
+  # RustFS API 的请求端点
+  S3_ENDPOINT=https://lobe-s3-api.example.com
+  # 存储桶的名称
+  S3_BUCKET=lobe
+  # 存储桶对外的访问域名
+  S3_PUBLIC_DOMAIN=https://lobe-s3-api.example.com
+  S3_ENABLE_PATH_STYLE=1
+  ```
 </Steps>

package/docs/self-hosting/advanced/upstream-sync.zh-CN.mdx

@@ -42,11 +42,11 @@ Docker 部署版本的升级非常简单，只需要重新部署 LobeHub 的最
 <Steps>
   ### 停止并删除当前运行的 LobeHub 容器
 
-  假设 LobeHub 容器的名称是 `lobe-chat`，使用以下指令停止并删除当前运行的 LobeHub 容器：
+  假设 LobeHub 容器的名称是 `lobehub`，使用以下指令停止并删除当前运行的 LobeHub 容器：
 
   ```fish
-  docker stop lobe-chat
-  docker rm lobe-chat
+  docker stop lobehub
+  docker rm lobehub
   ```
 
   ### 拉取最新的 LobeHub 镜像
@@ -54,7 +54,7 @@ Docker 部署版本的升级非常简单，只需要重新部署 LobeHub 的最
   使用以下命令拉取 LobeHub 的最新 Docker 镜像：
 
   ```fish
-  docker pull lobehub/lobe-chat
+  docker pull lobehub/lobehub
   ```
 
   ### 重新启动 Docker 容器
@@ -65,7 +65,7 @@ Docker 部署版本的升级非常简单，只需要重新部署 LobeHub 的最
   docker run -d -p 3210:3210 \
     -e OPENAI_API_KEY=sk-xxxx \
     -e OPENAI_PROXY_URL=https://api-proxy.com/v1 \
-    --name lobe-chat \
+    --name lobehub \
     lobehub/lobe-chat
   ```
 </Steps>

package/docs/self-hosting/auth/email.mdx

@@ -0,0 +1,70 @@
+---
+title: Email Service Configuration
+description: Configure LobeHub email service for email verification, password reset, and magic link login.
+tags:
+  - Email Service
+  - SMTP
+  - Resend
+  - Email Verification
+  - Magic Link
+---
+
+# Email Service Configuration
+
+Email service is used for email verification, password reset, and magic link delivery. LobeHub supports two email service providers.
+
+## Nodemailer (SMTP)
+
+Send emails via SMTP protocol, suitable for users with existing email services. See [Nodemailer SMTP docs](https://nodemailer.com/smtp/).
+
+| Environment Variable     | Type     | Description                                                    | Example               |
+| ------------------------ | -------- | -------------------------------------------------------------- | --------------------- |
+| `EMAIL_SERVICE_PROVIDER` | Optional | Set to `nodemailer` (default)                                  | `nodemailer`          |
+| `SMTP_HOST`              | Required | SMTP server hostname                                           | `smtp.gmail.com`      |
+| `SMTP_PORT`              | Required | SMTP server port (`587` for TLS, `465` for SSL)                | `587`                 |
+| `SMTP_SECURE`            | Optional | `true` for SSL (port 465), `false` for TLS (port 587)          | `false`               |
+| `SMTP_USER`              | Required | SMTP auth username                                             | `user@gmail.com`      |
+| `SMTP_PASS`              | Required | SMTP auth password                                             | `your-app-password`   |
+| `SMTP_FROM`              | Optional | Sender address (required for AWS SES), defaults to `SMTP_USER` | `noreply@example.com` |
+
+<Callout type={'warning'}>
+  When using Gmail, you must use an App Password instead of your account password. Generate one at [Google App Passwords](https://myaccount.google.com/apppasswords).
+</Callout>
+
+## Resend
+
+[Resend](https://resend.com/) is a modern email API service with simple setup, recommended for new users.
+
+| Environment Variable     | Type        | Description                               | Example                     |
+| ------------------------ | ----------- | ----------------------------------------- | --------------------------- |
+| `EMAIL_SERVICE_PROVIDER` | Required    | Set to `resend`                           | `resend`                    |
+| `RESEND_API_KEY`         | Required    | Resend API Key                            | `re_xxxxxxxxxxxxxxxxxxxxxx` |
+| `RESEND_FROM`            | Recommended | Sender address, must be a verified domain | `noreply@your-domain.com`   |
+
+<Callout type={'info'}>
+  Before using Resend, you need to [verify your sending domain](https://resend.com/docs/dashboard/domains/introduction), otherwise emails can only be sent to your own address.
+</Callout>
+
+## Email Verification
+
+Enable email verification to ensure users own the email addresses they register with (off by default):
+
+| Environment Variable      | Type     | Description                                                 |
+| ------------------------- | -------- | ----------------------------------------------------------- |
+| `AUTH_EMAIL_VERIFICATION` | Optional | Set to `1` to require email verification after registration |
+
+<Callout type={'info'}>
+  Email verification requires a working email service (SMTP or Resend) configured above. When enabled, users must verify their email address before they can sign in.
+</Callout>
+
+## Magic Link (Passwordless) Login
+
+Enable magic-link login (depends on a working email provider above, off by default):
+
+| Environment Variable     | Type     | Description                                                         |
+| ------------------------ | -------- | ------------------------------------------------------------------- |
+| `AUTH_ENABLE_MAGIC_LINK` | Optional | Set to `1` to enable passwordless magic-link login (off by default) |
+
+<Callout type={'tip'}>
+  Go to [Environment Variables](/docs/self-hosting/environment-variables/auth#better-auth) for detailed information on all Better Auth variables.
+</Callout>