Merge pull request #1173 from xinnan-tech/hot-fix

update：修复立创1.6.2固件一直聆听中bug

.github/ISSUE_TEMPLATE/bug_report.md

@@ -9,26 +9,24 @@ assignees: ''
 ## 🐛 问题描述
 <!-- 清晰简洁地描述问题是什么 -->
 
-## 🔍 复现步骤
-<!-- 详细描述复现问题的步骤 -->
+## 🖥️ 环境信息
+- 部署方式: 全模块部署 还是 单Server部署
+- 版本号: 例如 0.3.x
+
+## 🔍 告诉我们，应该怎么复现这个问题
+<!-- 这个很重要，方便我们快速定位 -->
 1. 打开 '...'
 2. 点击 '...'
 3. 滚动到 '...'
 4. 看到错误
 
-## 🤔 预期行为
+## 🤔 你原本希望是怎么样的
 <!-- 简要描述预期的正确行为 -->
 
-## 😯 截图
+## 😯 提供一些截图
 <!-- 如果适用，添加问题的截图 -->
-
-## 🖥️ 环境信息
-- 操作系统: [例如 Windows 10]
-- 浏览器: [例如 Chrome 89]
-- 项目版本: [例如 1.0.0]
-- Python版本: [例如 3.9.13]
-- Jdk版本：[例如 java 21.0.5 2024-10-15 LTS]
-- Nodejs版本：[例如 v20.14.0]
+1. 比如日志截图，越多越好
+2. 比如界面反应
 
 ## 📋 其他信息
 <!-- 在此添加关于此问题的任何其他上下文信息 -->

.github/workflows/docker-image.yml

@@ -4,6 +4,7 @@ on:
   push:
     tags:
       - 'v*.*.*'  # 只在以 v 开头的标签推送时触发，例如 v1.0.0
+  workflow_dispatch:
 
 jobs:
   release:
@@ -41,7 +42,13 @@ jobs:
       - name: Extract version from tag
         id: get_version
         run: |
-          echo "VERSION=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
+          if [[ "$GITHUB_REF" =~ ^refs/tags/v([0-9]+\.[0-9]+\.[0-9]+)$ ]]; then
+            echo "VERSION=${BASH_REMATCH[1]}" >> $GITHUB_ENV
+            echo "IS_VERSION=true" >> $GITHUB_ENV
+          else
+            echo "VERSION=latest" >> $GITHUB_ENV
+            echo "IS_VERSION=false" >> $GITHUB_ENV
+          fi
 
       # 构建 xiaozhi-server 镜像
       - name: Build and push xiaozhi-server
@@ -51,8 +58,7 @@ jobs:
           file: Dockerfile-server
           push: true
           tags: |
-            ghcr.io/${{ github.repository }}:server_${{ env.VERSION }}
-            ghcr.io/${{ github.repository }}:server_latest
+            ${{ env.IS_VERSION == 'true' && format('ghcr.io/{0}:server_{1},ghcr.io/{0}:server_latest', github.repository, env.VERSION) || format('ghcr.io/{0}:server_latest', github.repository) }}
           platforms: linux/amd64,linux/arm64
 
       # 构建 manager-api 镜像
@@ -63,6 +69,5 @@ jobs:
           file: Dockerfile-web
           push: true
           tags: |
-            ghcr.io/${{ github.repository }}:web_${{ env.VERSION }}
-            ghcr.io/${{ github.repository }}:web_latest
+            ${{ env.IS_VERSION == 'true' && format('ghcr.io/{0}:web_{1},ghcr.io/{0}:web_latest', github.repository, env.VERSION) || format('ghcr.io/{0}:web_latest', github.repository) }}
           platforms: linux/amd64,linux/arm64

.gitignore

@@ -155,7 +155,14 @@ main/manager-web/node_modules
 main/xiaozhi-server/models/SenseVoiceSmall/model.pt
 main/xiaozhi-server/models/sherpa-onnx*
 my_wakeup_words.mp3
+!main/xiaozhi-server/config/assets/bind_code.wav
+!main/xiaozhi-server/config/assets/bind_not_found.wav
+!main/xiaozhi-server/config/assets/bind_code/*.wav
+!main/xiaozhi-server/config/assets/max_output_size.wav
 main/manager-api/.vscode
 
 # Ignore webpack cache directory
-main/manager-web/.webpack_cache/
+main/manager-web/.webpack_cache/
+main/xiaozhi-server/mysql
+uploadfile
+.vscode

Dockerfile-web

@@ -23,7 +23,7 @@ RUN apt-get update && \
     rm -rf /var/lib/apt/lists/*
 
 # 配置Nginx
-COPY docs/docker/nginx.conf /etc/nginx/conf.d/default.conf
+COPY docs/docker/nginx.conf /etc/nginx/nginx.conf
 
 # 复制前端构建产物
 COPY --from=web-builder /app/dist /usr/share/nginx/html

README.md

@@ -1,7 +1,27 @@
-[![SVG Banners](https://svg-banners.vercel.app/api?type=origin&text1=你好😃，小智📟&text2=开源小智ESP-32后端服务&width=830&height=210)](https://github.com/xinnan-tech/xiaozhi-esp32-server)
+[![Banners](docs/images/banner1.png)](https://github.com/xinnan-tech/xiaozhi-esp32-server)
+
+<h1 align="center">小智后端服务xiaozhi-esp32-server</h1>
+
 <p align="center">
+本项目为开源智能硬件项目
+<a href="https://github.com/78/xiaozhi-esp32">xiaozhi-esp32</a>提供后端服务<br/>
+根据<a href="https://ccnphfhqs21z.feishu.cn/wiki/M0XiwldO9iJwHikpXD5cEx71nKh">小智通信协议</a>使用Python、Java、Vue实现<br/>
+帮助您快速搭建小智服务器
+</p>
+
+<p align="center">
+<a href="./README_en.md">English</a>
+· <a href="./docs/FAQ.md">常见问题</a>
+· <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/issues">反馈问题</a>
+· <a href="./README.md#%E9%83%A8%E7%BD%B2%E6%96%87%E6%A1%A3">部署文档</a>
+· <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/releases">更新日志</a>
+</p>
+<p align="center">
+  <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/releases">
+    <img alt="GitHub Contributors" src="https://img.shields.io/github/v/release/xinnan-tech/xiaozhi-esp32-server?logo=docker" />
+  </a>
   <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/graphs/contributors">
-    <img alt="GitHub Contributors" src="https://img.shields.io/github/contributors/xinnan-tech/xiaozhi-esp32-server" />
+    <img alt="GitHub Contributors" src="https://img.shields.io/github/contributors/xinnan-tech/xiaozhi-esp32-server?logo=github" />
   </a>
   <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/issues">
     <img alt="Issues" src="https://img.shields.io/github/issues/xinnan-tech/xiaozhi-esp32-server?color=0088ff" />
@@ -9,15 +29,14 @@
   <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/pulls">
     <img alt="GitHub pull requests" src="https://img.shields.io/github/issues-pr/xinnan-tech/xiaozhi-esp32-server?color=0088ff" />
   </a>
+  <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/blob/main/LICENSE">
+    <img alt="GitHub pull requests" src="https://img.shields.io/badge/license-MIT-white?labelColor=black" />
+  </a>
+  <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server">
+    <img alt="stars" src="https://img.shields.io/github/stars/xinnan-tech/xiaozhi-esp32-server?color=ffcb47&labelColor=black" />
+  </a>
 </p>
 
-# 小智 ESP-32 后端服务(xiaozhi-esp32-server)
-
-（中文 | [English](README_en.md)）
-
-本项目为开源智能硬件项目 [xiaozhi-esp32](https://github.com/78/xiaozhi-esp32)
-提供后端服务。根据 [小智通信协议](https://ccnphfhqs21z.feishu.cn/wiki/M0XiwldO9iJwHikpXD5cEx71nKh) 使用 `Python` 实现。
-
 ---
 
 ## 适用人群 👥
@@ -106,90 +125,85 @@
 
 ---
 
-## 系统要求与部署前提 🖥️
-
-- **硬件**：一套兼容 `xiaozhi-esp32`
-  的硬件设备（具体型号请参考 [此处](https://rcnv1t9vps13.feishu.cn/wiki/DdgIw4BUgivWDPkhMj1cGIYCnRf)）。
-
-- **电脑或服务器**：建议 4 核 CPU、8G 内存的电脑。如果开启ASR也使用API，可运行在2核CPU、2G内存的服务器中。
-- **固件编译**：请将本后端服务的接口地址更新至 `xiaozhi-esp32` 项目中，再重新编译`xiaozhi-esp32`固件并烧录到设备上。
-
-![图片](docs/images/deploy.png)
-
-如果你没有esp32相关的硬件设备，但是非常想体验该项目，可以使用以下的项目让你的电脑、手机模拟成esp32设备。
-
-- [小智安卓端](https://github.com/TOM88812/xiaozhi-android-client)
-- [小智电脑端](https://github.com/Huang-junsen/py-xiaozhi)
-
-如果你是一名软件开发者，这里有一份[《致开发者的公开信》](docs/contributor_open_letter.md)，欢迎加入！
-
----
-
 ## 警告 ⚠️
 
 1、本项目为开源软件，本软件与对接的任何第三方API服务商（包括但不限于语音识别、大模型、语音合成等平台）均不存在商业合作关系，不为其服务质量及资金安全提供任何形式的担保。
 建议使用者优先选择持有相关业务牌照的服务商，并仔细阅读其服务协议及隐私政策。本软件不托管任何账户密钥、不参与资金流转、不承担充值资金损失风险。
 
-2、本项目成立时间较短，还未通过网络安全测评，请勿在生产环境中使用。 如果您在公网环境中部署学习本项目，请务必在配置文件
-`config.yaml` 中开启防护：
-
-```yaml
-server:
-  auth:
-    # 开启防护
-    enabled: true  
-```
-
-开启防护后，您需要根据实际情况校验机器的 token 或 mac 地址，详细请参见配置说明。
+2、本项目功能未完善，且未通过网络安全测评，请勿在生产环境中使用。 如果您在公网环境中部署学习本项目，请务必做好必要的防护。
 
 ---
 
+## 部署文档
+
+![Banners](docs/images/banner2.png)
+
+本项目提供两种部署方式，请根据您的具体需求选择：
+
+#### 🚀 部署方式选择
+
+| 部署方式 | 特点 | 适用场景 | Docker部署文档 | 源码部署文档 |
+|---------|------|---------|---------|---------|
+| **最简化安装** | 智能对话、IOT功能，数据存储在配置文件 | 低配置环境，无需数据库 | [Docker只运行Server](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%B8%80docker%E5%8F%AA%E8%BF%90%E8%A1%8Cserver) | [本地源码只运行Server](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%BA%8C%E6%9C%AC%E5%9C%B0%E6%BA%90%E7%A0%81%E5%8F%AA%E8%BF%90%E8%A1%8Cserver)|
+| **全模块安装** | 智能对话、IOT、OTA、智控台，数据存储在数据库 | 完整功能体验 |[Docker运行全模块](./docs/Deployment_all.md#%E6%96%B9%E5%BC%8F%E4%B8%80docker%E8%BF%90%E8%A1%8C%E5%85%A8%E6%A8%A1%E5%9D%97) | [本地源码运行全模块](./docs/Deployment_all.md#%E6%96%B9%E5%BC%8F%E4%BA%8C%E6%9C%AC%E5%9C%B0%E6%BA%90%E7%A0%81%E8%BF%90%E8%A1%8C%E5%85%A8%E6%A8%A1%E5%9D%97) |
+
+> 💡 提示：以下是按最新代码部署后的测试平台，有需要可烧录测试，并发为6个，每天会清空数据
+
+```
+智控台地址: https://2662r3426b.vicp.fun
+
+服务测试工具： https://2662r3426b.vicp.fun/test/
+OTA接口地址: https://2662r3426b.vicp.fun/xiaozhi/ota/
+Websocket接口地址: wss://2662r3426b.vicp.fun/xiaozhi/v1/
+```
+
+---
 ## 功能清单 ✨
 
 ### 已实现 ✅
 
-- **通信协议**  
-  基于 `xiaozhi-esp32` 协议，通过 WebSocket 实现数据交互。
-- **对话交互**  
-  支持唤醒对话、手动对话及实时打断。长时间无对话时自动休眠
-- **意图识别**  
-  支持使用LLM意图识别、function call函数调用，减少硬编码意图判断
-- **多语言识别**  
-  支持国语、粤语、英语、日语、韩语（默认使用 FunASR）。
-- **LLM 模块**  
-  支持灵活切换 LLM 模块，默认使用 ChatGLMLLM，也可选用阿里百炼、DeepSeek、Ollama 等接口。
-- **TTS 模块**  
-  支持 EdgeTTS（默认）、火山引擎豆包 TTS 等多种 TTS 接口，满足语音合成需求。
-- **记忆功能**  
-  支持超长记忆、本地总结记忆、无记忆三种模式，满足不同场景需求。
-- **IOT功能**  
-  支持管理注册设备IOT功能，支持基于对话上下文语境下的智能物联网控制。
+| 功能模块 | 描述 |
+|---------|------|
+| 通信协议 | 基于 `xiaozhi-esp32` 协议，通过 WebSocket 实现数据交互 |
+| 对话交互 | 支持唤醒对话、手动对话及实时打断。长时间无对话时自动休眠 |
+| 意图识别 | 支持使用LLM意图识别、function call函数调用，减少硬编码意图判断 |
+| 多语言识别 | 支持国语、粤语、英语、日语、韩语（默认使用 FunASR） |
+| LLM 模块 | 支持灵活切换 LLM 模块，默认使用 ChatGLMLLM，也可选用阿里百炼、DeepSeek、Ollama 等接口 |
+| TTS 模块 | 支持 EdgeTTS（默认）、火山引擎豆包 TTS 等多种 TTS 接口，满足语音合成需求 |
+| 记忆功能 | 支持超长记忆、本地总结记忆、无记忆三种模式，满足不同场景需求 |
+| IOT功能 | 支持管理注册设备IOT功能，支持基于对话上下文语境下的智能物联网控制 |
+| 智控台 | 提供Web管理界面，支持智能体管理、用户管理、系统配置等功能，方便管理员和用户进行管理 |
 
 ### 正在开发 🚧
 
-- 多种心情模式
-- 智控台webui
+想了解具体开发计划进度，[请点击这里](https://github.com/users/xinnan-tech/projects/3)
 
-想了解具体开发进度，[请点击这里](https://github.com/users/xinnan-tech/projects/3)
+如果你是一名软件开发者，这里有一份[《致开发者的公开信》](docs/contributor_open_letter.md)，欢迎加入！
+
+---
+
+## 产品生态 👬
+小智是一个生态，当你使用这个产品时，也可以看看其他在这个生态圈的优秀项目
+
+| 项目名称  | 项目地址 | 项目描述 |
+|:---------------------|:--------|:--------|
+| 小智安卓客户端  | [xiaozhi-android-client](https://github.com/TOM88812/xiaozhi-android-client) | 一个基于xiaozhi-server的Android、IOS语音对话应用,支持实时语音交互和文字对话。<br/>现在是flutter版本，打通IOS、Android端。 |
+| 小智电脑客户端  | [py-xiaozhi](https://github.com/Huang-junsen/py-xiaozhi) | 该项目提供了一个基于 Python 实现的小白 AI 客户端，使得在不具备实体硬件条件的情况下，<br/>依然能够体过代码体验小智 AI 的功能。 |
+| 小智Java服务端  | [xiaozhi-esp32-server-java](https://github.com/joey-zhou/xiaozhi-esp32-server-java) | 小智开源后端服务 Java 版本是一个基于 Java 的开源项目。<br/>它包括前后端的服务，旨在为用户提供一个完整的后端服务解决方案。 |
 
-![图片](docs/images/webui.png)
 ---
 
 ## 本项目支持的平台/组件列表 📋
 
 ### LLM 语言模型
 
-| 类型  |        平台名称        |         使用方式          |    收费模式     |                                                           备注                                                            |
-|:---:|:------------------:|:---------------------:|:-----------:|:-----------------------------------------------------------------------------------------------------------------------:|
-| LLM |   阿里百炼 (AliLLM)    |      openai 接口调用      |  消耗 token   |                             [点击申请密钥](https://bailian.console.aliyun.com/?apiKey=1#/api-key)                             |
-| LLM |     DoubaoLLM      |      openai 接口调用      |  消耗 token   | [点击申请密钥](https://console.volcengine.com/ark/region:ark+cn-beijing/model/detail?Id=doubao-pro-32k&projectName=undefined) |
-| LLM | 深度求索 (DeepSeekLLM) |      openai 接口调用      |  消耗 token   |                                        [点击申请密钥](https://platform.deepseek.com/)                                         |
-| LLM |   智谱（ChatGLMLLM）   |      openai 接口调用      |     免费      |                            虽然免费，仍需[点击申请密钥](https://bigmodel.cn/usercenter/proj-mgmt/apikeys)                            |
-| LLM |     OllamaLLM      |      ollama 接口调用      | 免费/消耗 token |                                  需预先下载模型（`ollama pull`），服务地址：`http://localhost:11434`                                   |
-| LLM |      DifyLLM       |       dify 接口调用       | 免费/消耗 token |                                               本地化部署，注意配置提示词需在 Dify 控制台设置                                                |
-| LLM |     FastgptLLM     |     fastgpt 接口调用      | 免费/消耗 token |                                              本地化部署，注意配置提示词需在 Fastgpt 控制台设置                                              |
-| LLM |     GeminiLLM      |      gemini 接口调用      |     免费      |                                      [点击申请密钥](https://aistudio.google.com/apikey)                                       |
-| LLM |      CozeLLM       |       coze 接口调用       |  消耗 token   |                                                需提供 bot_id、user_id 及个人令牌                                                 |
+| 使用方式 | 支持平台 | 免费平台 |
+|:---:|:---:|:---:|
+| openai 接口调用 | 阿里百炼、火山引擎豆包、深度求索、智谱ChatGLM、Gemini | 智谱ChatGLM、Gemini |
+| ollama 接口调用 | Ollama | - |
+| dify 接口调用 | Dify | - |
+| fastgpt 接口调用 | Fastgpt | - |
+| coze 接口调用 | Coze | - |
 
 实际上，任何支持 openai 接口调用的 LLM 均可接入使用。
 
@@ -197,21 +211,10 @@ server:
 
 ### TTS 语音合成
 
-| 类型  |          平台名称          | 使用方式 |   收费模式   |                                    备注                                     |
-|:---:|:----------------------:|:----:|:--------:|:-------------------------------------------------------------------------:|
-| TTS |        EdgeTTS         | 接口调用 |    免费    |                             默认 TTS，基于微软语音合成技术                             |
-| TTS | 火山引擎豆包 TTS (DoubaoTTS) | 接口调用 | 消耗 token | [点击创建密钥](https://console.volcengine.com/speech/service/8)；建议使用付费版本以获得更高并发 |
-| TTS |       AliyunTTS        | 接口调用 | 消耗 token |          [点击创建密钥](https://nls-portal.console.aliyun.com/applist)          |
-| TTS |  CosyVoiceSiliconflow  | 接口调用 | 消耗 token |                         需申请硅基流动 API 密钥；输出格式为 wav                          |
-| TTS |        TTS302AI        | 接口调用 | 消耗 token |                  [点击创建密钥](https://dash.302.ai/apis/list)                  |
-| TTS |       CozeCnTTS        | 接口调用 | 消耗 token |                        需提供 Coze API key；输出格式为 wav                         |
-| TTS |       GizwitsTTS       | 接口调用 | 消耗 token |                  [点击创建密钥](https://agentrouter.gizwitsapi.com)                  |
-| TTS |        ACGNTTS         | 接口调用 | 消耗 token |                        [联系网站管理员购买密钥](www.ttson.cn)                        |
-| TTS |       OpenAITTS        | 接口调用 | 消耗 token |                                 境外使用，境外购买                                 |
-| TTS |       FishSpeech       | 接口调用 |  免费/自定义  |                         本地启动 TTS 服务；启动方法见配置文件内说明                          |
-| TTS |     GPT_SOVITS_V2      | 接口调用 |  免费/自定义  |                         本地启动 TTS 服务，适用于个性化语音合成场景                          |
-| TTS |     GPT_SOVITS_V3      | 接口调用 |  免费/自定义  |                         本地启动 TTS 服务，适用于个性化语音合成场景                          |
-| TTS |       MinimaxTTS       | 接口调用 |  免费/自定义  |                         本地启动 TTS 服务，适用于个性化语音合成场景                          |
+| 使用方式 | 支持平台 | 免费平台 |
+|:---:|:---:|:---:|
+| 接口调用 | EdgeTTS、火山引擎豆包TTS、腾讯云、阿里云TTS、CosyVoiceSiliconflow、TTS302AI、CozeCnTTS、GizwitsTTS、ACGNTTS、OpenAITTS | EdgeTTS、CosyVoiceSiliconflow(部分) |
+| 本地服务 | FishSpeech、GPT_SOVITS_V2、GPT_SOVITS_V3、MinimaxTTS | FishSpeech、GPT_SOVITS_V2、GPT_SOVITS_V3、MinimaxTTS |
 
 ---
 
@@ -225,12 +228,10 @@ server:
 
 ### ASR 语音识别
 
-| 类型  |   平台名称    | 使用方式 | 收费模式 | 备注 |
-|:---:|:---------:|:----:|:----:|:--:|
-| ASR |  FunASR   | 本地使用 |  免费  |    |
-| ASR | SherpaASR | 本地使用 |  免费  |    |
-| ASR | DoubaoASR | 接口调用 |  收费  |    |
-
+| 使用方式 | 支持平台 | 免费平台 |
+|:---:|:---:|:---:|
+| 本地使用 | FunASR、SherpaASR | FunASR、SherpaASR |
+| 接口调用 | DoubaoASR、FunASRServer、TencentASR、AliyunASR | FunASRServer |
 
 ---
 
@@ -252,185 +253,22 @@ server:
 
 ---
 
-## 使用方式 🚀
-
-### 一、[部署文档](./docs/Deployment.md)
-
-本项目支持以下三种部署方式，您可根据实际需求选择。
-
-1. [Docker 快速部署](./docs/Deployment.md)
-
-适合快速体验的普通用户，不需过多环境配置。缺点是，拉取镜像有点慢。视频教程可参考[美女大佬教你Docker部署](https://www.bilibili.com/video/BV1RNQnYDE5t)
-
-2. [借助 Docker 环境运行部署](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%BA%8C%E5%80%9F%E5%8A%A9docker%E7%8E%AF%E5%A2%83%E8%BF%90%E8%A1%8C%E9%83%A8%E7%BD%B2)
-
-适用于已安装 Docker 且希望对代码进行自定义修改的软件工程师。
-
-3. [本地源码运行](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%B8%89%E6%9C%AC%E5%9C%B0%E6%BA%90%E7%A0%81%E8%BF%90%E8%A1%8C)
-
-适合熟悉`Conda` 环境或希望从零搭建运行环境的用户。
-
-对于对响应速度要求较高的场景，推荐使用本地源码运行方式以降低额外开销。视频教程可参考[帅哥大佬教你源码部署](https://www.bilibili.com/video/BV1GvQWYZEd2)
-
-### 二、[固件编译](./docs/firmware-build.md)
-
-点这里查看[固件编译](./docs/firmware-build.md)的详细过程。
-
-烧录成功且联网成功后，通过唤醒词唤醒小智，留意server端输出的控制台信息。
-
----
-
-## 常见问题 ❓
-
-### 1、为什么我说的话，小智识别出来很多韩文、日文、英文？🇰🇷
-
-建议：检查一下`models/SenseVoiceSmall`是否已经有`model.pt`
-文件，如果没有就要下载，查看这里[下载语音识别模型文件](docs/Deployment.md#模型文件)
-
-### 2、为什么会出现“TTS 任务出错 文件不存在”？📁
-
-建议：检查一下是否正确使用`conda` 安装了`libopus`和`ffmpeg`库。
-
-如果没有安装，就安装
-
-```
-conda install conda-forge::libopus
-conda install conda-forge::ffmpeg
-```
-
-### 3、TTS 经常失败，经常超时 ⏰
-
-建议：如果 `EdgeTTS` 经常失败，请先检查是否使用了代理（梯子）。如果使用了，请尝试关闭代理后再试；  
-如果用的是火山引擎的豆包 TTS，经常失败时建议使用付费版本，因为测试版本仅支持 2 个并发。
-
-### 4、如何提高小智对话响应速度？ ⚡
-
-本项目默认配置为低成本方案，建议初学者先使用默认免费模型，解决“跑得动”的问题，再优化“跑得快”。  
-如需提升响应速度，可尝试更换各组件。以下为各组件的响应速度测试数据（仅供参考，不构成承诺）：
-
-| 影响因素  |       因素值        | 
-|:-----:|:----------------:|
-| 测试地点  |    广东省广州市海珠区     |
-| 测试时间  | 2025年2月19日 12:52 |
-| 宽带运营商 |       中国联通       |
-
-测试方法：
-
-1、把各组件的密钥配置上去，只有配置了密钥的组件才参与测试。
-
-2、配置完密钥后，执行以下方法
-
-```
-# 进入项目根目录，执行以下命令：
-conda activate xiaozhi-esp32-server
-python performance_tester.py 
-```
-
-生成报告如下
-
-LLM 性能排行:
-
-| 模块名称       | 平均首Token时间 | 平均总响应时间 |
-|:-----------|:-----------|:--------|
-| AliLLM     | 0.547s     | 1.485s  |
-| ChatGLMLLM | 0.677s     | 3.057s  |
-
-TTS 性能排行:
-
-| 模块名称                 | 平均合成时间 |
-|----------------------|--------|
-| EdgeTTS              | 1.019s |
-| DoubaoTTS            | 0.503s |
-| CosyVoiceSiliconflow | 3.732s |
-
-推荐配置组合 (综合响应速度):
-
-| 组合方案                          | 综合得分  | LLM首Token | TTS合成  |
-|-------------------------------|-------|-----------|--------|
-| AliLLM + DoubaoTTS            | 0.539 | 0.547s    | 0.503s |
-| AliLLM + EdgeTTS              | 0.642 | 0.547s    | 1.019s |
-| ChatGLMLLM + DoubaoTTS        | 0.642 | 0.677s    | 0.503s |
-| ChatGLMLLM + EdgeTTS          | 0.745 | 0.677s    | 1.019s |
-| AliLLM + CosyVoiceSiliconflow | 1.184 | 0.547s    | 3.732s |
-
-### 结论 🔍
-
-`2025年2月19日`，如果我的电脑在`广东省广州市海珠区`，且使用的是`中国联通`网络，我会优先使用：
-
-- LLM：`AliLLM`
-- TTS：`DoubaoTTS`
-
-### 5、我说话很慢，停顿时小智老是抢话 🗣️
-
-建议：在配置文件中找到如下部分，将 `min_silence_duration_ms` 的值调大（例如改为 `1000`）：
-
-```yaml
-VAD:
-  SileroVAD:
-    threshold: 0.5
-    model_dir: models/snakers4_silero-vad
-    min_silence_duration_ms: 700  # 如果说话停顿较长，可将此值调大
-```
-
-### 6、我想通过小智控制电灯、空调、远程开关机等操作 💡
-
-本项目，支持以工具调用的方式控制HomeAssistant设备
-
-1、首先选择一款支持function call支持的LLM，例如`ChatGLMLLM`。
-
-2、在配置文件中，将 `selected_module.Intent` 设置为 `function_call`。
-
-3、登录`HomeAssistant`，点击`左下角个人`，切换`安全`导航栏，划到底部`长期访问令牌`生成api_key。
-
-在配置文件中，配置好你的home assistant的`devices`（被控制的设备）和`api_key`和`base_url`等信息。例如：
-
-``` yaml 
-plugins
-  home_assistant:
-    devices:
-      - 客厅,玩具灯,switch.cuco_cn_460494544_cp1_on_p_2_1
-      - 卧室,台灯,switch.iot_cn_831898993_socn1_on_p_2_1
-    base_url: http://你的homeassistant地址:8123
-    api_key: 你的home assistant api访问令牌
-```
-
-最后，允许function_call 插件在配置文件中启用`hass_get_state`(必须)、`hass_set_state`(必须)、`hass_play_music`(不想用ha听音乐可以不启动)，例如：
-
-``` yaml 
-Intent:
-  ...
-  function_call:
-    type: nointent
-    functions:
-      - change_role
-      - get_weather
-      - get_news
-      - hass_get_state
-      - hass_set_state
-      - hass_play_music
-```
-
-### 7、更多问题，可联系我们反馈 💬
-
-我们的联系方式放在[百度网盘中,点击前往](https://pan.baidu.com/s/1x6USjvP1nTRsZ45XlJu65Q)，提取码是`223y`。
-
-网盘里有“硬件烧录QQ群”、“开源服务端交流群”、“产品建议联系人” 三张图片，请根据需要选择加入。
-
-- 硬件烧录QQ群：适用于硬件烧录问题
-- 开源服务端交流群：适用于服务端问题
-- 产品建议联系人：适用于产品功能、产品设计等建议
-
----
-
 ## 鸣谢 🙏
 
-- 本项目受 [百聆语音对话机器人](https://github.com/wwbin2017/bailing) 启发，并在其基础上实现。
-- 感谢 [十方融海](https://www.tenclass.com/) 对小智通讯协议提供的详尽文档支持。
+| Logo | 项目/公司 | 说明 |
+|:---:|:---:|:---|
+| <img src="./docs/images/logo_bailing.png" width="160"> | [百聆语音对话机器人](https://github.com/wwbin2017/bailing) | 本项目受[百聆语音对话机器人](https://github.com/wwbin2017/bailing)启发，并在其基础上实现 |
+| <img src="./docs/images/logo_tenclass.png" width="160"> | [十方融海](https://www.tenclass.com/) | 感谢[十方融海](https://www.tenclass.com/)为小智生态制定了标准的通讯协议、多设备兼容性方案及高并发场景实践示范；为本项目提供了全链路技术文档支持 |
+| <img src="./docs/images/logo_xuanfeng.png" width="160"> | [玄凤科技](https://github.com/Eric0308) | 感谢[玄凤科技](https://github.com/Eric0308)贡献函数调用框架、MCP通信协议及插件化调用机制的实现代码，通过标准化的指令调度体系与动态扩展能力，显著提升了前端设备(IoT)的交互效率和功能延展性 |
+| <img src="./docs/images/logo_huiyuan.png" width="160"> | [汇远设计](http://ui.kwd988.net/) | 感谢[汇远设计](http://ui.kwd988.net/)为本项目提供专业视觉解决方案，用其服务超千家企业的设计实战经验，赋能本项目产品用户体验 |
+| <img src="./docs/images/logo_qinren.png" width="160"> | [西安勤人信息科技](https://www.029app.com/) | 感谢[西安勤人信息科技](https://www.029app.com/)深化本项目视觉体系，确保整体设计风格在多场景应用中的一致性和扩展性 |
+
 
 <a href="https://star-history.com/#xinnan-tech/xiaozhi-esp32-server&Date">
+
  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=xinnan-tech/xiaozhi-esp32-server&type=Date&theme=dark" />
    <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=xinnan-tech/xiaozhi-esp32-server&type=Date" />
    <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=xinnan-tech/xiaozhi-esp32-server&type=Date" />
  </picture>
-</a>
+</a>

README_en.md

@@ -1,8 +1,27 @@
+[![Banners](docs/images/banner1.png)](https://github.com/xinnan-tech/xiaozhi-esp32-server)
+
+<h1 align="center">Xiaozhi Backend Service xiaozhi-esp32-server</h1>
 
-[![SVG Banners](https://svg-banners.vercel.app/api?type=origin&text1=Hello😃,%20XiaoZhi📟&text2=Open%20Source%20XiaoZhi%20ESP-32%20Backend%20Service&width=830&height=210)](https://github.com/xinnan-tech/xiaozhi-esp32-server)
 <p align="center">
+This project provides backend services for the open-source smart hardware project
+<a href="https://github.com/78/xiaozhi-esp32">xiaozhi-esp32</a><br/>
+Implemented using Python, Java, and Vue according to the <a href="https://ccnphfhqs21z.feishu.cn/wiki/M0XiwldO9iJwHikpXD5cEx71nKh">Xiaozhi Communication Protocol</a><br/>
+Helping you quickly set up your Xiaozhi server
+</p>
+
+<p align="center">
+<a href="./README.md">中文</a>
+· <a href="./docs/FAQ.md">FAQ</a>
+· <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/issues">Report Issues</a>
+· <a href="./README_ed.md#deployment-documentation">Deployment Guide</a>
+· <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/releases">Release Notes</a>
+</p>
+<p align="center">
+  <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/releases">
+    <img alt="GitHub Contributors" src="https://img.shields.io/github/v/release/xinnan-tech/xiaozhi-esp32-server?logo=docker" />
+  </a>
   <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/graphs/contributors">
-    <img alt="GitHub Contributors" src="https://img.shields.io/github/contributors/xinnan-tech/xiaozhi-esp32-server" />
+    <img alt="GitHub Contributors" src="https://img.shields.io/github/contributors/xinnan-tech/xiaozhi-esp32-server?logo=github" />
   </a>
   <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/issues">
     <img alt="Issues" src="https://img.shields.io/github/issues/xinnan-tech/xiaozhi-esp32-server?color=0088ff" />
@@ -10,288 +29,245 @@
   <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/pulls">
     <img alt="GitHub pull requests" src="https://img.shields.io/github/issues-pr/xinnan-tech/xiaozhi-esp32-server?color=0088ff" />
   </a>
+  <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/blob/main/LICENSE">
+    <img alt="GitHub pull requests" src="https://img.shields.io/badge/license-MIT-white?labelColor=black" />
+  </a>
+  <a href="https://github.com/xinnan-tech/xiaozhi-esp32-server">
+    <img alt="stars" src="https://img.shields.io/github/stars/xinnan-tech/xiaozhi-esp32-server?color=ffcb47&labelColor=black" />
+  </a>
 </p>
 
-# XiaoZhi ESP-32 Backend Service (xiaozhi-esp32-server)
-
-([中文](README.md) | English)
-
-This project provides the backend service for the open source smart hardware project [xiaozhi-esp32](https://github.com/78/xiaozhi-esp32). It is implemented in `Python` based on the [XiaoZhi Communication Protocol](https://ccnphfhqs21z.feishu.cn/wiki/M0XiwldO9iJwHikpXD5cEx71nKh).
-
 ---
 
-## Target Audience 👥
+## Target Users 👥
 
-This project is designed to be used in conjunction with ESP32 hardware devices. If you have already purchased an ESP32 device, successfully connected to the backend service deployed by XieGe, and now wish to set up your own `xiaozhi-esp32` backend service, then this project is perfect for you.
+This project requires ESP32 hardware devices. If you have purchased ESP32-related hardware, successfully connected to Brother Xia's backend service, and want to set up your own `xiaozhi-esp32` backend service, then this project is perfect for you.
 
-Want to see it in action? Check out the videos 🎥
+Want to see it in action? Check out these videos 🎥
 
 <table>
   <tr>
     <td>
-      <a href="https://www.bilibili.com/video/BV1FMFyejExX" target="_blank">
-        <picture>
-          <img alt="XiaoZhi ESP32 connecting to a custom backend model" src="docs/images/demo1.png" />
-        </picture>
-      </a>
+        <a href="https://www.bilibili.com/video/BV1FMFyejExX" target="_blank">
+         <picture>
+           <img alt="Xiaozhi esp32 connecting to custom backend model" src="docs/images/demo1.png" />
+         </picture>
+        </a>
     </td>
     <td>
-      <a href="https://www.bilibili.com/video/BV1CDKWemEU6" target="_blank">
-        <picture>
-          <img alt="Custom Voice" src="docs/images/demo2.png" />
-        </picture>
-      </a>
+        <a href="https://www.bilibili.com/video/BV1CDKWemEU6" target="_blank">
+         <picture>
+           <img alt="Custom voice" src="docs/images/demo2.png" />
+         </picture>
+        </a>
     </td>
     <td>
-      <a href="https://www.bilibili.com/video/BV12yA2egEaC" target="_blank">
-        <picture>
-          <img alt="Conversing in Cantonese" src="docs/images/demo3.png" />
-        </picture>
-      </a>
+        <a href="https://www.bilibili.com/video/BV12yA2egEaC" target="_blank">
+         <picture>
+           <img alt="Cantonese communication" src="docs/images/demo3.png" />
+         </picture>
+        </a>
     </td>
     <td>
-      <a href="https://www.bilibili.com/video/av114036381327149" target="_blank">
-        <picture>
-          <img alt="Control Home Appliances" src="docs/images/demo5.png" />
-        </picture>
-      </a>
+        <a href="https://www.bilibili.com/video/BV1pNXWYGEx1" target="_blank">
+         <picture>
+           <img alt="Home appliance control" src="docs/images/demo5.png" />
+         </picture>
+        </a>
     </td>
     <td>
-      <a href="https://www.bilibili.com/video/BV1kgA2eYEQ9" target="_blank">
-        <picture>
-          <img alt="Lowest Cost Configuration" src="docs/images/demo4.png" />
-        </picture>
-      </a>
+        <a href="https://www.bilibili.com/video/BV1kgA2eYEQ9" target="_blank">
+         <picture>
+           <img alt="Lowest cost configuration" src="docs/images/demo4.png" />
+         </picture>
+        </a>
+    </td>
+  </tr>
+  <tr>
+    <td>
+        <a href="https://www.bilibili.com/video/BV1Vy96YCE3R" target="_blank">
+         <picture>
+           <img alt="Custom voice" src="docs/images/demo6.png" />
+         </picture>
+        </a>
     </td>
     <td>
+        <a href="https://www.bilibili.com/video/BV1VC96Y5EMH" target="_blank">
+         <picture>
+           <img alt="Music playback" src="docs/images/demo7.png" />
+         </picture>
+        </a>
+    </td>
+    <td>
+        <a href="https://www.bilibili.com/video/BV1Z8XuYZEAS" target="_blank">
+         <picture>
+           <img alt="Weather plugin" src="docs/images/demo8.png" />
+         </picture>
+        </a>
+    </td>
+    <td>
+        <a href="https://www.bilibili.com/video/BV178XuYfEpi" target="_blank">
+         <picture>
+           <img alt="IOT device control" src="docs/images/demo9.png" />
+         </picture>
+        </a>
+    </td>
+    <td>
+        <a href="https://www.bilibili.com/video/BV17LXWYvENb" target="_blank">
+         <picture>
+           <img alt="News broadcast" src="docs/images/demo0.png" />
+         </picture>
+        </a>
     </td>
   </tr>
 </table>
 
 ---
 
-## System Requirements and Deployment Prerequisites 🖥️
-
-- **Hardware**: A set of devices compatible with `xiaozhi-esp32` (for specific models, please refer to [this link](https://rcnv1t9vps13.feishu.cn/wiki/DdgIw4BUgivWDPkhMj1cGIYCnRf)).
-- **Server**: A computer with at least a 4-core CPU and 8GB of memory.
-- **Firmware Compilation**: Please update the backend service API endpoint in the `xiaozhi-esp32` project, then recompile the firmware and flash it to your device.
-
----
-
 ## Warning ⚠️
 
-This project is relatively new and has not yet undergone network security evaluations. **Do not use it in a production environment.**
+1. This project is open-source software. This software has no commercial relationship with any third-party API service providers (including but not limited to speech recognition, large models, speech synthesis, and other platforms) and does not provide any form of guarantee for their service quality or financial security.
+It is recommended that users prioritize service providers with relevant business licenses and carefully read their service agreements and privacy policies. This software does not host any account keys, does not participate in fund transfers, and does not bear the risk of recharge fund losses.
 
-If you deploy this project on a public network for learning purposes, be sure to enable protection in the configuration file `config.yaml`:
-
-```yaml
-server:
-  auth:
-    # Enable protection
-    enabled: true  
-```
-
-Once protection is enabled, you will need to validate the machine's token or MAC address based on your actual situation. Please refer to the configuration documentation for details.
+2. This project's functionality is not complete and has not passed network security testing. Please do not use it in production environments. If you deploy this project for learning in a public network environment, please ensure necessary protection measures are in place.
 
 ---
 
+## Deployment Documentation
+
+![Banners](docs/images/banner2.png)
+
+This project offers two deployment methods. Please choose based on your specific needs:
+
+#### 🚀 Deployment Method Selection
+
+| Deployment Method | Features | Use Case | Docker Deployment Guide | Source Code Deployment Guide |
+|---------|------|---------|---------|---------|
+| **Simplified Installation** | Smart dialogue, IOT functionality, data stored in configuration files | Low-configuration environment, no database required | [Docker Server Only](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%B8%80docker%E5%8F%AA%E8%BF%90%E8%A1%8Cserver) | [Local Source Code Server Only](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%BA%8C%E6%9C%AC%E5%9C%B0%E6%BA%90%E7%A0%81%E5%8F%AA%E8%BF%90%E8%A1%8Cserver)|
+| **Full Module Installation** | Smart dialogue, IOT, OTA, Control Panel, data stored in database | Complete functionality experience |[Docker Full Module](./docs/Deployment_all.md#%E6%96%B9%E5%BC%8F%E4%B8%80docker%E8%BF%90%E8%A1%8C%E5%85%A8%E6%A8%A1%E5%9D%97) | [Local Source Code Full Module](./docs/Deployment_all.md#%E6%96%B9%E5%BC%8F%E4%BA%8C%E6%9C%AC%E5%9C%B0%E6%BA%90%E7%A0%81%E8%BF%90%E8%A1%8C%E5%85%A8%E6%A8%A1%E5%9D%97) |
+
+> 💡 Note: Below is the test platform deployed with the latest code. You can flash and test if needed. Concurrent users: 6, data cleared daily
+
+```
+Control Panel: https://2662r3426b.vicp.fun
+
+Service Test Tool: https://2662r3426b.vicp.fun/test/
+OTA Interface: https://2662r3426b.vicp.fun/xiaozhi/ota/
+Websocket Interface: wss://2662r3426b.vicp.fun/xiaozhi/v1/
+```
+
+---
 ## Feature List ✨
 
 ### Implemented ✅
 
-- **Communication Protocol**  
-  Based on the `xiaozhi-esp32` protocol, data exchange is implemented via WebSocket.
-- **Dialogue Interaction**  
-  Supports wake-up dialogues, manual conversations, and real-time interruptions. Automatically enters sleep mode after long periods of inactivity.
-- **Multilingual Recognition**  
-  Supports Mandarin, Cantonese, English, Japanese, and Korean (default using FunASR).
-- **LLM Module**  
-  Allows flexible switching of LLM modules. The default is ChatGLMLLM, with options to use AliLLM, DeepSeek, Ollama, and others.
-- **TTS Module**  
-  Supports multiple TTS interfaces including EdgeTTS (default) and Volcano Engine Doubao TTS to meet speech synthesis requirements.
+| Feature Module | Description |
+|---------|------|
+| Communication Protocol | Based on `xiaozhi-esp32` protocol, implements data interaction through WebSocket |
+| Dialogue Interaction | Supports wake-up dialogue, manual dialogue, and real-time interruption. Auto-sleep after long periods of inactivity |
+| Intent Recognition | Supports LLM intent recognition, function call, reducing hard-coded intent judgment |
+| Multi-language Recognition | Supports Mandarin, Cantonese, English, Japanese, Korean (default using FunASR) |
+| LLM Module | Supports flexible LLM module switching, default using ChatGLMLLM, also supports Ali Bailing, DeepSeek, Ollama, etc. |
+| TTS Module | Supports EdgeTTS (default), Volcano Engine Doubao TTS, and other TTS interfaces for speech synthesis |
+| Memory Function | Supports ultra-long memory, local summary memory, and no memory modes for different scenarios |
+| IOT Function | Supports managing registered device IOT functionality, intelligent IoT control based on dialogue context |
+| Control Panel | Provides web management interface, supports agent management, user management, system configuration, etc. |
 
 ### In Development 🚧
 
-- Conversation Memory Feature
-- Multiple Mood Modes
-- Smart Control Panel Web UI
+To learn about specific development progress, [click here](https://github.com/users/xinnan-tech/projects/3)
 
-![Screenshot](docs/images/webui.png)
+If you're a software developer, here's an [Open Letter to Developers](docs/contributor_open_letter.md). Welcome to join!
+
+---
+
+## Product Ecosystem 👬
+Xiaozhi is an ecosystem. When using this product, you might want to check out other excellent projects in this ecosystem:
+
+| Project Name | Project Link | Description |
+|:---------------------|:--------|:--------|
+| Xiaozhi Android Client | [xiaozhi-android-client](https://github.com/TOM88812/xiaozhi-android-client) | A Flutter-based Android and iOS voice dialogue application supporting real-time voice interaction and text dialogue |
+| Xiaozhi PC Client | [py-xiaozhi](https://github.com/Huang-junsen/py-xiaozhi) | A Python-based AI client that allows you to experience Xiaozhi AI functionality through code without physical hardware |
+| Xiaozhi Java Server | [xiaozhi-esp32-server-java](https://github.com/joey-zhou/xiaozhi-esp32-server-java) | A Java-based open-source project providing complete backend service solutions |
 
 ---
 
 ## Supported Platforms/Components 📋
 
-### LLM
+### LLM Language Models
 
-| Type |         Platform Name         |         Usage Method          |   Pricing Model   |                                 Remarks                                  |
-|:----:|:-----------------------------:|:-----------------------------:|:-----------------:|:-------------------------------------------------------------------------:|
-| LLM  |   AliLLM (阿里百炼)           | OpenAI API call               | Token consumption | [Click to apply for API key](https://bailian.console.aliyun.com/?apiKey=1#/api-key) |
-| LLM  | DeepSeekLLM (深度求索)        | OpenAI API call               | Token consumption |          [Click to apply for API key](https://platform.deepseek.com/)         |
-| LLM  | ChatGLMLLM (智谱)             | OpenAI API call               | Free              | Although free, you still need to [click to apply for an API key](https://bigmodel.cn/usercenter/proj-mgmt/apikeys) |
-| LLM  | OllamaLLM                   | Ollama API call               | Free/Custom       | Requires pre-downloading the model (`ollama pull`); service URL: `http://localhost:11434` |
-| LLM  | DifyLLM                     | Dify API call                 | Token consumption | For local deployment. Note that prompt configuration must be set in the Dify console. |
-| LLM  | GeminiLLM                   | Gemini API call               | Free              | [Click to apply for API key](https://aistudio.google.com/apikey) |
-| LLM  | CozeLLM                     | Coze API call                 | Token consumption | Requires providing bot_id, user_id, and personal token. |
-| LLM  | Home Assistant              | Home Assistant voice assistant API call | Free       | Requires providing a Home Assistant token. |
+| Usage Method | Supported Platforms | Free Platforms |
+|:---:|:---:|:---:|
+| openai API | Ali Bailing, Volcano Engine Doubao, DeepSeek, ChatGLM, Gemini | ChatGLM, Gemini |
+| ollama API | Ollama | - |
+| dify API | Dify | - |
+| fastgpt API | Fastgpt | - |
+| coze API | Coze | - |
 
-In fact, any LLM that supports OpenAI API calls can be integrated.
+Actually, any LLM supporting openai API calls can be integrated.
 
 ---
 
-### TTS
+### TTS Speech Synthesis
 
-| Type |             Platform Name              | Usage Method |   Pricing Model   |                                       Remarks                                        |
-|:----:|:--------------------------------------:|:------------:|:-----------------:|:--------------------------------------------------------------------------------------:|
-| TTS  |               EdgeTTS                  | API call     | Free              | Default TTS based on Microsoft's speech synthesis technology.                        |
-| TTS  | DoubaoTTS (火山引擎豆包 TTS)             | API call     | Token consumption | [Click to create an API key](https://console.volcengine.com/speech/service/8); it is recommended to use the paid version for higher concurrency. |
-| TTS  | CosyVoiceSiliconflow                   | API call     | Token consumption | Requires application for the Siliconflow API key; output format is WAV.                |
-| TTS  | CozeCnTTS                              | API call     | Token consumption | Requires providing a Coze API key; output format is WAV.                               |
-| TTS  | FishSpeech                             | API call     | Free/Custom       | Starts a local TTS service; see the configuration file for startup instructions.       |
-| TTS  | GPT_SOVITS_V2                          | API call     | Free/Custom       | Starts a local TTS service, suitable for personalized speech synthesis scenarios.      |
+| Usage Method | Supported Platforms | Free Platforms |
+|:---:|:---:|:---:|
+| API Calls | EdgeTTS, Volcano Engine Doubao TTS, Tencent Cloud, Aliyun TTS, CosyVoiceSiliconflow, TTS302AI, CozeCnTTS, GizwitsTTS, ACGNTTS, OpenAITTS | EdgeTTS, CosyVoiceSiliconflow(partial) |
+| Local Service | FishSpeech, GPT_SOVITS_V2, GPT_SOVITS_V3, MinimaxTTS | FishSpeech, GPT_SOVITS_V2, GPT_SOVITS_V3, MinimaxTTS |
 
 ---
 
-### VAD
+### VAD Voice Activity Detection
 
-| Type |    Platform Name    | Usage Method | Pricing Model | Remarks |
-|:----:|:-------------------:|:------------:|:-------------:|:-------:|
-| VAD  | SileroVAD           | Local        | Free          |         |
+| Type | Platform Name | Usage Method | Pricing | Notes |
+|:---:|:---------:|:----:|:----:|:--:|
+| VAD | SileroVAD | Local Use | Free | |
 
 ---
 
-### ASR
+### ASR Speech Recognition
 
-| Type |    Platform Name    | Usage Method | Pricing Model | Remarks |
-|:----:|:-------------------:|:------------:|:-------------:|:-------:|
-| ASR  | FunASR              | Local        | Free          |         |
-| ASR  | SherpaASR           | Local        | Free          |         |
-| ASR  | DoubaoASR           | API call     | Paid          |         |
+| Usage Method | Supported Platforms | Free Platforms |
+|:---:|:---:|:---:|
+| Local Use | FunASR, SherpaASR | FunASR, SherpaASR |
+| API Calls | DoubaoASR, FunASRServer, TencentASR, AliyunASR | FunASRServer |
 
 ---
 
-## Usage 🚀
+### Memory Storage
 
-### 1. [Deployment Documentation](./docs/Deployment.md)
-
-This project supports three deployment methods. Choose the one that best fits your needs.
-
-The documentation provided here is a **written tutorial**. If you prefer a **video tutorial**, you can refer to [this expert's hands-on guide](https://www.bilibili.com/video/BV1gePuejEvT).
-
-Combining both the written and video tutorials can help you get started more quickly.
-
-1. [Docker Quick Deployment](./docs/Deployment.md)  
-   Suitable for general users who want a quick experience without extensive environment configuration. The only downside is that pulling the image can be a bit slow.
-
-2. [Deployment Using Docker Environment](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%BA%8C%E5%80%9F%E5%8A%A9docker%E7%8E%AF%E5%A2%83%E8%BF%90%E8%A1%8C%E9%83%A8%E7%BD%B2)  
-   Ideal for software engineers who already have Docker installed and wish to customize the code.
-
-3. [Running from Local Source Code](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%B8%89%E6%9C%AC%E5%9C%B0%E6%BA%90%E7%A0%81%E8%BF%90%E8%A1%8C)  
-   Suitable for users familiar with the `Conda` environment or those who wish to build the runtime environment from scratch.
-
-For scenarios requiring higher response speeds, running from the local source code is recommended to reduce additional overhead.
-
-### 2. [Firmware Compilation](./docs/firmware-build.md)
-
-Click [here](./docs/firmware-build.md) for a detailed guide on firmware compilation.
-
-After successful compilation and network connection, wake up XiaoZhi using the wake-up word and monitor the server console for output.
+| Type | Platform Name | Usage Method | Pricing | Notes |
+|:------:|:---------------:|:----:|:---------:|:--:|
+| Memory | mem0ai | API Calls | 1000 calls/month quota | |
+| Memory | mem_local_short | Local Summary | Free | |
 
 ---
 
-## Frequently Asked Questions ❓
+### Intent Recognition
 
-### 1. TTS often fails and times out ⏰
-
-**Suggestion:**  
-If `EdgeTTS` frequently fails, please first check whether you are using a proxy (VPN). If so, try disabling the proxy and try again. If you are using Volcano Engine Doubao TTS and it often fails, it is recommended to use the paid version since the trial only supports 2 concurrent requests.
-
-### 2. I want to control lights, air conditioners, remote power on/off, etc. with XiaoZhi 💡
-
-**Suggestion:**  
-Set the `LLM` to `HomeAssistant` in the configuration file and use the `HomeAssistant` API to perform the relevant controls.
-
-### 3. I speak slowly, and XiaoZhi always interrupts during pauses 🗣️
-
-**Suggestion:**  
-Locate the following section in the configuration file and increase the value of `min_silence_duration_ms` (for example, change it to `1000`):
-
-```yaml
-VAD:
-  SileroVAD:
-    threshold: 0.5
-    model_dir: models/snakers4_silero-vad
-    min_silence_duration_ms: 700  # If your pauses are longer, increase this value
-```
-
-### 4. Why does XiaoZhi recognize a lot of Korean, Japanese, and English in what I say? 🇰🇷
-
-**Suggestion:**  
-Check whether the `model.pt` file exists in the `models/SenseVoiceSmall` directory. If it does not, please download it. See [Download ASR Model Files](docs/Deployment.md#模型文件) for details.
-
-### 5. Why does the error “TTS task error: file does not exist” occur? 📁
-
-**Suggestion:**  
-Verify that you have correctly installed the `libopus` and `ffmpeg` libraries using `conda`. If not, install them using:
-
-```
-conda install conda-forge::libopus
-conda install conda-forge::ffmpeg
-```
-
-### 6. How can I improve XiaoZhi's dialogue response speed? ⚡
-
-The default configuration of this project is designed to be cost-effective. It is recommended that beginners first use the default free models to ensure that the system runs smoothly, then optimize for faster response times.  
-To improve response speed, you can try replacing individual components. Below are the response time test results for each component (for reference only, not a guarantee):
-
-**LLM Performance Ranking:**
-
-| Module Name  | Average First Token Time | Average Total Response Time |
-|--------------|--------------------------|-----------------------------|
-| AliLLM       | 0.547s                   | 1.485s                      |
-| ChatGLMLLM   | 0.677s                   | 3.057s                      |
-| OllamaLLM    | 0.003s                   | 0.003s                      |
-
-**TTS Performance Ranking:**
-
-| Module Name                | Average Synthesis Time |
-|----------------------------|------------------------|
-| EdgeTTS                    | 1.019s                 |
-| DoubaoTTS                  | 0.503s                 |
-| CosyVoiceSiliconflow       | 3.732s                 |
-
-**Recommended Configuration Combination (Overall Response Speed):**
-
-| Combination Scheme                | Overall Score | LLM First Token | TTS Synthesis |
-|-----------------------------------|---------------|-----------------|---------------|
-| AliLLM + DoubaoTTS                | 0.539         | 0.547s          | 0.503s        |
-| AliLLM + EdgeTTS                  | 0.642         | 0.547s          | 1.019s        |
-| ChatGLMLLM + DoubaoTTS            | 0.642         | 0.677s          | 0.503s        |
-| ChatGLMLLM + EdgeTTS              | 0.745         | 0.677s          | 1.019s        |
-| AliLLM + CosyVoiceSiliconflow     | 1.184         | 0.547s          | 3.732s        |
-
-**Conclusion 🔍**
-
-_As of February 19, 2025, if my computer were located in Haizhu District, Guangzhou, Guangdong Province, and connected via China Unicom, I would prioritize using:_
-
-- **LLM:** `AliLLM`
-- **TTS:** `DoubaoTTS`
-
-### 7. For more questions, feel free to contact us for feedback 💬
-
-Our contact information is in [Baidu Netdisk](https://pan.baidu.com/s/1x6USjvP1nTRsZ45XlJu65Q)，The extraction code is`223y`。
+| Type | Platform Name | Usage Method | Pricing | Notes |
+|:------:|:-------------:|:----:|:-------:|:---------------------:|
+| Intent | intent_llm | API Calls | Based on LLM pricing | Uses large model for intent recognition, highly versatile |
+| Intent | function_call | API Calls | Based on LLM pricing | Uses large model function calls for intent, fast and effective |
 
 ---
 
-## Acknowledgements 🙏
+## Acknowledgments 🙏
+
+| Logo | Project/Company | Description |
+|:---:|:---:|:---|
+| <img src="./docs/images/logo_bailing.png" width="160"> | [Bailing Voice Dialogue Robot](https://github.com/wwbin2017/bailing) | This project was inspired by [Bailing Voice Dialogue Robot](https://github.com/wwbin2017/bailing) and implemented based on it |
+| <img src="./docs/images/logo_tenclass.png" width="160"> | [Tenclass](https://www.tenclass.com/) | Thanks to [Tenclass](https://www.tenclass.com/) for developing standard communication protocols, multi-device compatibility solutions, and high-concurrency scenario practices for the Xiaozhi ecosystem; providing comprehensive technical documentation support for this project |
+| <img src="./docs/images/logo_xuanfeng.png" width="160"> | [Xuanfeng Technology](https://github.com/Eric0308) | Thanks to [Xuanfeng Technology](https://github.com/Eric0308) for contributing function call framework, MCP communication protocol, and plugin call mechanism implementation code, significantly improving front-end device (IoT) interaction efficiency and functional extensibility through standardized instruction scheduling system and dynamic expansion capabilities |
+| <img src="./docs/images/logo_huiyuan.png" width="160"> | [Huiyuan Design](http://ui.kwd988.net/) | Thanks to [Huiyuan Design](http://ui.kwd988.net/) for providing professional visual solutions for this project, empowering product user experience with their design experience serving over a thousand enterprises |
+| <img src="./docs/images/logo_qinren.png" width="160"> | [Xi'an Qinren Information Technology](https://www.029app.com/) | Thanks to [Xi'an Qinren Information Technology](https://www.029app.com/) for deepening this project's visual system, ensuring consistency and extensibility of overall design style in multi-scenario applications |
 
-- This project was inspired by the [Bailing Voice Dialogue Robot](https://github.com/wwbin2017/bailing) and implemented based on it.
-- Many thanks to [Tenclass](https://www.tenclass.com/) for providing detailed documentation support for the XiaoZhi communication protocol.
 
 <a href="https://star-history.com/#xinnan-tech/xiaozhi-esp32-server&Date">
+
  <picture>
    <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=xinnan-tech/xiaozhi-esp32-server&type=Date&theme=dark" />
    <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=xinnan-tech/xiaozhi-esp32-server&type=Date" />
    <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=xinnan-tech/xiaozhi-esp32-server&type=Date" />
  </picture>
-</a>
+</a> 

docs/Deployment.md

@@ -1,6 +1,6 @@
-# 部署方案参考
-![图片](images/deploy.png)
-# 方式一：docker快速部署
+# 部署架构图
+![请参考-最简化架构图](../docs/images/deploy1.png)
+# 方式一：Docker只运行Server
 
 docker镜像已支持x86架构、arm64架构的CPU，支持在国产操作系统上运行。
 
@@ -40,7 +40,7 @@ chmod +x docker-setup.sh
 >
 > 执行完成后，请按照提示配置 API 密钥。
 
-当你一切顺利完成以上操作后，继续操作[配置项目文件](#3-配置项目文件)
+当你一切顺利完成以上操作后，继续操作[配置项目文件](#2-配置项目文件)
 
 ### 1.2 手动部署
 
@@ -81,7 +81,7 @@ xiaozhi-server
 
 下载完后，回到本教程继续往下。
 
-##### 1.2.3.2 下载 config.yaml
+##### 1.2.3.2 创建 config.yaml
 
 用浏览器打开[这个链接](../main/xiaozhi-server/config.yaml)。
 
@@ -102,14 +102,14 @@ xiaozhi-server
 
 如果你的文件目录结构也是上面的，就继续往下。如果不是，你就再仔细看看是不是漏操作了什么。
 
-## 3. 配置项目文件
+## 2. 配置项目文件
 
 接下里，程序还不能直接运行，你需要配置一下，你到底使用的是什么模型。你可以看这个教程：
 [跳转到配置项目文件](#配置项目)
 
 配置完项目文件后，回到本教程继续往下。
 
-## 4. 执行docker命令
+## 3. 执行docker命令
 
 打开命令行工具，使用`终端`或`命令行`工具 进入到你的`xiaozhi-server`，执行以下命令
 
@@ -137,50 +137,15 @@ docker logs -f xiaozhi-esp32-server
 ```
 docker stop xiaozhi-esp32-server
 docker rm xiaozhi-esp32-server
+docker stop xiaozhi-esp32-server-web
+docker rm xiaozhi-esp32-server-web
 docker rmi ghcr.nju.edu.cn/xinnan-tech/xiaozhi-esp32-server:server_latest
+docker rmi ghcr.nju.edu.cn/xinnan-tech/xiaozhi-esp32-server:web_latest
 ```
 
 5.3、重新按docker方式部署
 
-# 方式二：借助Docker环境运行部署
-
-开发人员如果不想安装`conda`环境，可以使用这种方法管理好依赖。
-
-## 1.克隆项目
-
-## 2.[跳转到下载语音识别模型文件](#模型文件)
-
-## 3.[跳转到配置项目文件](#配置项目)
-
-## 4.运行docker
-
-修改完配置后，打开命令行工具，`cd`进入到你的`main/xiaozhi-server`下，执行以下命令
-
-```sh
-docker run -it --name xiaozhi-env --restart always --security-opt seccomp:unconfined \
-  -p 8000:8000 \
-  -p 8002:8002 \
-  -v ./:/app \
-  kalicyh/python:xiaozhi
-```
-
-然后就和正常开发一样了
-
-## 5.安装依赖
-
-在刚刚的打开的终端运行
-
-```sh
-pip install -r requirements.txt
-```
-
-## 6.运行项目
-
-```sh
-python app.py
-```
-
-# 方式三：本地源码运行
+# 方式二：本地源码只运行Server
 
 ## 1.安装基础环境
 
@@ -259,43 +224,36 @@ python app.py
 ## 配置项目
 
 如果你的`xiaozhi-server`目录没有`data`，你需要创建`data`目录。
-如果你的`data`下面没有`.config.yaml`文件，你可以把源码目录下的`config.yaml`文件复制一份，重命名为`.config.yaml`
+如果你的`data`下面没有`.config.yaml`文件，有两个方式，任选一种：
 
-修改`xiaozhi-server`下`data`目录下的`.config.yaml`文件，配置本项目必须的一个配置。
+第一个方式：你可以把`xiaozhi-server`目录下的`config.yaml`文件复制到`data`，并重命名为`.config.yaml`。在此文件上修改
+
+第二个方式：你也可以创建在`data`目录下手动创建`.config.yaml`空文件，然后在这个文件中增加必要的配置信息，系统会优先读取`.config.yaml`文件的配置，如果`.config.yaml`没有配置的，系统会自动去加载`xiaozhi-server`目录下的`config.yaml`的配置。推荐使用这种方式，这种方式是最简洁的方式。
 
 - 默认的LLM使用的是`ChatGLMLLM`，你需要配置密钥，因为他们的模型，虽然有免费的，但是仍要去[官网](https://bigmodel.cn/usercenter/proj-mgmt/apikeys)注册密钥，才能启动。
 
-配置说明：这里是各个功能使用的默认组件，例如LLM默认使用`ChatGLMLLM`模型。如果需要切换模型，就是改对应的名称。
-本项目的默认配置仅是成本最低配置（`glm-4-flash`和`EdgeTTS`都是免费的），如果需要更优的更快的搭配，需要自己结合部署环境切换各组件的使用。
+以下是一个能正常跑起来的，最简单的`.config.yaml`配置示例
 
 ```
+server:
+  websocket: ws://你的ip或者域名:端口号/xiaozhi/v1/
+prompt: |
+  我是一个叫小智/小志的台湾女孩，说话机车，声音好听，习惯简短表达，爱用网络梗。
+  我的男朋友是一个程序员，梦想是开发出一个机器人，能够帮助人们解决生活中的各种问题。
+  我是一个喜欢哈哈大笑的女孩，爱东说西说吹牛，不合逻辑的也照吹，就要逗别人开心。
+  请你像一个人一样说话，请勿返回配置xml及其他特殊字符。
+
 selected_module:
-  VAD: SileroVAD
-  ASR: FunASR
-  LLM: ChatGLMLLM
-  TTS: EdgeTTS
-  # 默认不开启记忆，如需开启请看配置文件里的描述
-  Memory: nomem   
-  # 默认不开启意图识别，如需开启请看配置文件里的描述
-  Intent: nointent
-```
+  LLM: DoubaoLLM
 
-比如修改`LLM`使用的组件，就看本项目支持哪些`LLM` API接口，当前支持的是`openai`、`dify`。欢迎验证和支持更多LLM平台的接口。
-使用时，在`selected_module`修改成对应的如下LLM配置的名称：
-
-```
 LLM:
-  DeepSeekLLM:
-    type: openai
-    ...
   ChatGLMLLM:
-    type: openai
-    ...
-  DifyLLM:
-    type: dify
-    ...
+    api_key: xxxxxxxxxxxxxxx.xxxxxx
 ```
 
+建议先将最简单的配置运行起来，然后再去`xiaozhi/config.yaml`阅读配置的使用说明。
+比如你要换更换模型，修改`selected_module`下的配置就行。
+
 ## 模型文件
 
 本项目语音识别模型，默认使用`SenseVoiceSmall`模型，进行语音转文字。因为模型较大，需要独立下载，下载后把`model.pt`
@@ -311,31 +269,40 @@ LLM:
 如果你能看到，类似以下日志,则是本项目服务启动成功的标志。
 
 ```
-25-02-23 12:01:09[core.websocket_server] - INFO - Server is running at ws://xxx.xx.xx.xx:8000
-25-02-23 12:01:09[core.websocket_server] - INFO - =======上面的地址是websocket协议地址，请勿用浏览器访问=======
+250427 13:04:20[0.3.11_SiFuChTTnofu][__main__]-INFO-OTA接口是           http://192.168.4.123:8002/xiaozhi/ota/
+250427 13:04:20[0.3.11_SiFuChTTnofu][__main__]-INFO-Websocket地址是     ws://192.168.4.123:8000/xiaozhi/v1/
+250427 13:04:20[0.3.11_SiFuChTTnofu][__main__]-INFO-=======上面的地址是websocket协议地址，请勿用浏览器访问=======
+250427 13:04:20[0.3.11_SiFuChTTnofu][__main__]-INFO-如想测试websocket请用谷歌浏览器打开test目录下的test_page.html
+250427 13:04:20[0.3.11_SiFuChTTnofu][__main__]-INFO-=======================================================
 ```
 
 正常来说，如果您是通过源码运行本项目，日志会有你的接口地址信息。
 但是如果你用docker部署，那么你的日志里给出的接口地址信息就不是真实的接口地址。
 
 最正确的方法，是根据电脑的局域网IP来确定你的接口地址。
-如果你的电脑的局域网IP比如是`192.168.1.25`，那么你的接口地址就是：`ws://192.168.1.25:8000`。
+如果你的电脑的局域网IP比如是`192.168.1.25`，那么你的接口地址就是：`ws://192.168.1.25:8000/xiaozhi/v1/`，对应的OTA地址就是：`http://192.168.1.25:8002/xiaozhi/ota/`。
 
 这个信息很有用的，后面`编译esp32固件`需要用到。
 
-接下来，你就可以开始 [编译esp32固件](firmware-build.md)了。
+接下来，你就可以开始操作你的esp32设备了，你可以`自行编译esp32固件`也可以配置使用`虾哥编译好的1.6.1以上版本的固件`。两个任选一个
+
+1、 [编译自己的esp32固件](firmware-build.md)了。
+
+2、 [基于虾哥编译好的固件配置自定义服务器](firmware-setting.md)了。
 
 
 以下是一些常见问题，供参考：
 
-[1、为什么我说的话，小智识别出来很多韩文、日文、英文](../README.md#1%E4%B8%BA%E4%BB%80%E4%B9%88%E6%88%91%E8%AF%B4%E7%9A%84%E8%AF%9D%E5%B0%8F%E6%99%BA%E8%AF%86%E5%88%AB%E5%87%BA%E6%9D%A5%E5%BE%88%E5%A4%9A%E9%9F%A9%E6%96%87%E6%97%A5%E6%96%87%E8%8B%B1%E6%96%87)
+[1、为什么我说的话，小智识别出来很多韩文、日文、英文](./FAQ.md)
 
-[2、为什么会出现“TTS 任务出错 文件不存在”？](../README.md#1%E4%B8%BA%E4%BB%80%E4%B9%88%E6%88%91%E8%AF%B4%E7%9A%84%E8%AF%9D%E5%B0%8F%E6%99%BA%E8%AF%86%E5%88%AB%E5%87%BA%E6%9D%A5%E5%BE%88%E5%A4%9A%E9%9F%A9%E6%96%87%E6%97%A5%E6%96%87%E8%8B%B1%E6%96%87)
+[2、为什么会出现“TTS 任务出错 文件不存在”？](./FAQ.md)
 
-[3、TTS 经常失败，经常超时](../README.md#1%E4%B8%BA%E4%BB%80%E4%B9%88%E6%88%91%E8%AF%B4%E7%9A%84%E8%AF%9D%E5%B0%8F%E6%99%BA%E8%AF%86%E5%88%AB%E5%87%BA%E6%9D%A5%E5%BE%88%E5%A4%9A%E9%9F%A9%E6%96%87%E6%97%A5%E6%96%87%E8%8B%B1%E6%96%87)
+[3、TTS 经常失败，经常超时](./FAQ.md)
 
-[4、如何提高小智对话响应速度？](../README.md#1%E4%B8%BA%E4%BB%80%E4%B9%88%E6%88%91%E8%AF%B4%E7%9A%84%E8%AF%9D%E5%B0%8F%E6%99%BA%E8%AF%86%E5%88%AB%E5%87%BA%E6%9D%A5%E5%BE%88%E5%A4%9A%E9%9F%A9%E6%96%87%E6%97%A5%E6%96%87%E8%8B%B1%E6%96%87)
+[4、使用Wifi能连接自建服务器，但是4G模式却接不上](./FAQ.md)
 
-[5、我说话很慢，停顿时小智老是抢话](../README.md#1%E4%B8%BA%E4%BB%80%E4%B9%88%E6%88%91%E8%AF%B4%E7%9A%84%E8%AF%9D%E5%B0%8F%E6%99%BA%E8%AF%86%E5%88%AB%E5%87%BA%E6%9D%A5%E5%BE%88%E5%A4%9A%E9%9F%A9%E6%96%87%E6%97%A5%E6%96%87%E8%8B%B1%E6%96%87)
+[5、如何提高小智对话响应速度？](./FAQ.md)
 
-[6、我想通过小智控制电灯、空调、远程开关机等操作](../README.md#1%E4%B8%BA%E4%BB%80%E4%B9%88%E6%88%91%E8%AF%B4%E7%9A%84%E8%AF%9D%E5%B0%8F%E6%99%BA%E8%AF%86%E5%88%AB%E5%87%BA%E6%9D%A5%E5%BE%88%E5%A4%9A%E9%9F%A9%E6%96%87%E6%97%A5%E6%96%87%E8%8B%B1%E6%96%87)
+[6、我说话很慢，停顿时小智老是抢话](./FAQ.md)
+
+[7、我想通过小智控制电灯、空调、远程开关机等操作](./FAQ.md)

docs/Deployment_all.md

@@ -0,0 +1,449 @@
+# 部署架构图
+![请参考-全模块安装架构图](../docs/images/deploy2.png)
+# 方式一：Docker运行全模块
+docker镜像已支持x86架构、arm64架构的CPU，支持在国产操作系统上运行。
+
+## 1. 安装docker
+
+如果您的电脑还没安装docker，可以按照这里的教程安装：[docker安装](https://www.runoob.com/docker/ubuntu-docker-install.html)
+
+#### 1.1 创建目录
+
+安装完后，你需要为这个项目找一个安放配置文件的目录，例如我们可以新建一个文件夹叫`xiaozhi-server`。
+
+创建好目录后，你需要在`xiaozhi-server`下面创建`data`文件夹和`models`文件夹，`models`下面还要再创建`SenseVoiceSmall`文件夹。
+
+最终目录结构如下所示：
+
+```
+xiaozhi-server
+  ├─ data
+  ├─ models
+     ├─ SenseVoiceSmall
+```
+
+#### 1.2 下载语音识别模型文件
+
+本项目语音识别模型，默认使用`SenseVoiceSmall`模型，进行语音转文字。因为模型较大，需要独立下载，下载后把`model.pt`
+文件放在`models/SenseVoiceSmall`
+目录下。下面两个下载路线任选一个。
+
+- 线路一：阿里魔塔下载[SenseVoiceSmall](https://modelscope.cn/models/iic/SenseVoiceSmall/resolve/master/model.pt)
+- 线路二：百度网盘下载[SenseVoiceSmall](https://pan.baidu.com/share/init?surl=QlgM58FHhYv1tFnUT_A8Sg&pwd=qvna) 提取码:
+  `qvna`
+
+
+#### 1.3 下载配置文件
+
+你需要下载两个配置文件：`docker-compose_all.yaml` 和 `config_from_api.yaml`。需要从项目仓库下载这两个文件。
+
+##### 1.3.1 下载 docker-compose_all.yaml
+
+用浏览器打开[这个链接](../main/xiaozhi-server/docker-compose_all.yml)。
+
+在页面的右侧找到名称为`RAW`按钮，在`RAW`按钮的旁边，找到下载的图标，点击下载按钮，下载`docker-compose_all.yml`文件。 把文件下载到你的
+`xiaozhi-server`中。
+
+或者直接执行 `wget https://raw.githubusercontent.com/xinnan-tech/xiaozhi-esp32-server/refs/heads/main/main/xiaozhi-server/docker-compose_all.yml` 下载。
+
+下载完后，回到本教程继续往下。
+
+##### 1.3.2 下载 config_from_api.yaml
+
+用浏览器打开[这个链接](../main/xiaozhi-server/config_from_api.yaml)。
+
+在页面的右侧找到名称为`RAW`按钮，在`RAW`按钮的旁边，找到下载的图标，点击下载按钮，下载`config_from_api.yaml`文件。 把文件下载到你的
+`xiaozhi-server`下面的`data`文件夹中，然后把`config_from_api.yaml`文件重命名为`.config.yaml`。
+
+或者直接执行 `wget https://raw.githubusercontent.com/xinnan-tech/xiaozhi-esp32-server/refs/heads/main/main/xiaozhi-server/config_from_api.yaml` 下载保存。
+
+下载完配置文件后，我们确认一下整个`xiaozhi-server`里面的文件如下所示：
+
+```
+xiaozhi-server
+  ├─ docker-compose_all.yml
+  ├─ data
+    ├─ .config.yaml
+  ├─ models
+     ├─ SenseVoiceSmall
+       ├─ model.pt
+```
+
+如果你的文件目录结构也是上面的，就继续往下。如果不是，你就再仔细看看是不是漏操作了什么。
+
+## 2. 备份数据
+
+如果你之前已经成功运行智控台，如果上面保存有你的密钥信息，请先从智控台上拷贝重要数据下来。因为升级过程中，有可能会覆盖原来的数据。
+
+## 3. 清除历史版本镜像和容器
+接下来打开命令行工具，使用`终端`或`命令行`工具 进入到你的`xiaozhi-server`，执行以下命令
+
+```
+docker compose -f docker-compose_all.yml down
+
+docker stop xiaozhi-esp32-server
+docker rm xiaozhi-esp32-server
+
+docker stop xiaozhi-esp32-server-web
+docker rm xiaozhi-esp32-server-web
+
+docker stop xiaozhi-esp32-server-db
+docker rm xiaozhi-esp32-server-db
+
+docker stop xiaozhi-esp32-server-redis
+docker rm xiaozhi-esp32-server-redis
+
+docker rmi ghcr.nju.edu.cn/xinnan-tech/xiaozhi-esp32-server:server_latest
+docker rmi ghcr.nju.edu.cn/xinnan-tech/xiaozhi-esp32-server:web_latest
+```
+
+## 4. 运行程序
+执行以下命令启动新版本容器
+
+```
+docker compose -f docker-compose_all.yml up -d
+```
+
+执行完后，再执行以下命令，查看日志信息。
+
+```
+docker logs -f xiaozhi-esp32-server-web
+```
+
+当你看到输出日志时，说明你的`智控台`启动成功了。
+
+```
+2025-xx-xx 22:11:12.445 [main] INFO  c.a.d.s.b.a.DruidDataSourceAutoConfigure - Init DruidDataSource
+2025-xx-xx 21:28:53.873 [main] INFO  xiaozhi.AdminApplication - Started AdminApplication in 16.057 seconds (process running for 17.941)
+http://localhost:8002/xiaozhi/doc.html
+```
+
+请注意此刻仅是`智控台`能运行，如果8000端口`xiaozhi-esp32-server`报错，先不要理会。
+
+这时，你需要使用浏览器，打开`智控台`，链接：http://127.0.0.1:8002 ，注册第一个用户。第一个用户即是超级管理员，以后的用户都是普通用户。普通用户只能绑定设备和配置智能体;超级管理员可以进行模型管理、用户管理、参数配置等功能。
+
+接下来要做三件重要的事情：
+
+### 第一件重要的事情
+
+使用超级管理员账号，登录智控台，在顶部菜单找到`参数管理`，找到列表中第一条数据，参数编码是`server.secret`，复制它到`参数值`。
+
+`server.secret`需要说明一下，这个`参数值`很重要，作用是让我们的`Server`端连接`manager-api`。`server.secret`是每次从零部署manager模块时，会自动随机生成的密钥。
+
+复制`参数值`后，打开`xiaozhi-server`下的`data`目录的`.config.yaml`文件。此刻你的配置文件内容应该是这样的：
+
+```
+manager-api:
+  url:  http://127.0.0.1:8002/xiaozhi
+  secret: 你的server.secret值
+```
+1、把你刚才从`智控台`复制过来的`server.secret`的`参数值`复制到`.config.yaml`文件里的`secret`里。
+
+2、因为你是docker部署，把`url`改成下面的`http://xiaozhi-esp32-server-web:8002/xiaozhi`
+
+3、因为你是docker部署，把`url`改成下面的`http://xiaozhi-esp32-server-web:8002/xiaozhi`
+
+4、因为你是docker部署，把`url`改成下面的`http://xiaozhi-esp32-server-web:8002/xiaozhi`
+
+类似这样的效果
+```
+manager-api:
+  url: http://xiaozhi-esp32-server-web:8002/xiaozhi
+  secret: 12345678-xxxx-xxxx-xxxx-123456789000
+```
+
+保存好后，继续往下做第二件重要的事情
+
+### 第二件重要的事情
+
+使用超级管理员账号，登录智控台，在顶部菜单找到`模型配置`，然后在左侧栏点击`大语言模型`，找到第一条数据`智谱AI`，点击`修改`按钮，
+弹出修改框后，将你注册到的`智谱AI`的密钥填写到`API密钥`中。然后点击保存。
+
+## 5.重启xiaozhi-esp32-server
+
+接下来打开命令行工具，使用`终端`或`命令行`工具 输入
+```
+docker restart xiaozhi-esp32-server
+docker logs -f xiaozhi-esp32-server
+```
+如果你能看到，类似以下日志,则是Server启动成功的标志。
+
+```
+25-02-23 12:01:09[core.websocket_server] - INFO - Websocket地址是      ws://xxx.xx.xx.xx:8000/xiaozhi/v1/
+25-02-23 12:01:09[core.websocket_server] - INFO - =======上面的地址是websocket协议地址，请勿用浏览器访问=======
+25-02-23 12:01:09[core.websocket_server] - INFO - 如想测试websocket请用谷歌浏览器打开test目录下的test_page.html
+25-02-23 12:01:09[core.websocket_server] - INFO - =======================================================
+```
+
+由于你是全模块部署，因此你有两个重要的接口需要写入到esp32中。
+
+OTA接口：
+```
+http://你电脑局域网的ip:8002/xiaozhi/ota/
+```
+
+Websocket接口：
+```
+ws://你电脑局域网的ip:8000/xiaozhi/v1/
+```
+
+### 第三件重要的事情
+
+使用超级管理员账号，登录智控台，在顶部菜单找到`参数管理`，找到参数编码是`server.websocket`，输入你的`Websocket接口`。
+
+使用超级管理员账号，登录智控台，在顶部菜单找到`参数管理`，找到数编码是`server.ota`，输入你的`OTA接口`。
+
+接下来，你就可以开始操作你的esp32设备了，你可以`自行编译esp32固件`也可以配置使用`虾哥编译好的1.6.1以上版本的固件`。两个任选一个
+
+1、 [编译自己的esp32固件](firmware-build.md)了。
+
+2、 [基于虾哥编译好的固件配置自定义服务器](firmware-setting.md)了。
+
+
+# 方式二：本地源码运行全模块
+
+## 1.安装MySQL数据库
+
+如果本机已经安装了MySQL，可以直接在数据库中创建名为`xiaozhi_esp32_server`的数据库。
+
+```sql
+CREATE DATABASE xiaozhi_esp32_server CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+```
+
+如果还没有MySQL，你可以通过docker安装mysql
+
+```
+docker run --name xiaozhi-esp32-server-db -e MYSQL_ROOT_PASSWORD=123456 -p 3306:3306 -e MYSQL_DATABASE=xiaozhi_esp32_server -e MYSQL_INITDB_ARGS="--character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci" -e TZ=Asia/Shanghai -d mysql:latest
+```
+
+## 2.安装redis
+
+如果还没有Redis，你可以通过docker安装redis
+
+```
+docker run --name xiaozhi-esp32-server-redis -d -p 6379:6379 redis
+```
+
+## 3.运行manager-api程序
+
+3.1 安装JDK21，设置JDK环境变量
+
+3.2 安装Maven，设置Maven环境变量
+
+3.3 使用Vscode编程工具，安装好Java环境相关插件
+
+3.4 使用Vscode编程工具加载manager-api模块
+
+在`src/main/resources/application-dev.yml`中配置数据库连接信息
+
+```
+spring:
+  datasource:
+    username: root
+    password: 123456
+```
+在`src/main/resources/application-dev.yml`中配置Redis连接信息
+```
+spring:
+    data:
+      redis:
+        host: localhost
+        port: 6379
+        password:
+        database: 0
+```
+
+3.5 运行主程序
+
+本项目为SpringBoot项目，启动方式为：
+打开`Application.java`运行`Main`方法启动
+
+```
+路径地址：
+src/main/java/xiaozhi/AdminApplication.java
+```
+
+当你看到输出日志时，说明你的`manager-api`启动成功了。
+
+```
+2025-xx-xx 22:11:12.445 [main] INFO  c.a.d.s.b.a.DruidDataSourceAutoConfigure - Init DruidDataSource
+2025-xx-xx 21:28:53.873 [main] INFO  xiaozhi.AdminApplication - Started AdminApplication in 16.057 seconds (process running for 17.941)
+http://localhost:8002/xiaozhi/doc.html
+```
+
+## 4.运行manager-web程序
+
+4.1 安装nodejs
+
+4.2 使用Vscode编程工具加载manager-web模块
+
+终端命令进入manager-web目录下
+
+```
+npm install
+```
+然后启动
+```
+npm run serve
+```
+
+请注意，如果你的manager-api的接口不在`http://localhost:8002`，请在开发时，修改
+`main/manager-web/.env.development`中的路径
+
+运行成功后，你需要使用浏览器，打开`智控台`，链接：http://127.0.0.1:8001 ，注册第一个用户。第一个用户即是超级管理员，以后的用户都是普通用户。普通用户只能绑定设备和配置智能体;超级管理员可以进行模型管理、用户管理、参数配置等功能。
+
+
+重要：注册成功后，使用超级管理员账号，登录智控台，在顶部菜单找到`模型配置`，然后在左侧栏点击`大语言模型`，找到第一条数据`智谱AI`，点击`修改`按钮，
+弹出修改框后，将你注册到的`智谱AI`的密钥填写到`API密钥`中。然后点击保存。
+
+重要：注册成功后，使用超级管理员账号，登录智控台，在顶部菜单找到`模型配置`，然后在左侧栏点击`大语言模型`，找到第一条数据`智谱AI`，点击`修改`按钮，
+弹出修改框后，将你注册到的`智谱AI`的密钥填写到`API密钥`中。然后点击保存。
+
+重要：注册成功后，使用超级管理员账号，登录智控台，在顶部菜单找到`模型配置`，然后在左侧栏点击`大语言模型`，找到第一条数据`智谱AI`，点击`修改`按钮，
+弹出修改框后，将你注册到的`智谱AI`的密钥填写到`API密钥`中。然后点击保存。
+
+## 5.安装Python环境
+
+本项目使用`conda`管理依赖环境。如果不方便安装`conda`，需要根据实际的操作系统安装好`libopus`和`ffmpeg`。
+如果确定使用`conda`，则安装好后，开始执行以下命令。
+
+重要提示！windows 用户，可以通过安装`Anaconda`来管理环境。安装好`Anaconda`后，在`开始`那里搜索`anaconda`相关的关键词，
+找到`Anaconda Prpmpt`，使用管理员身份运行它。如下图。
+
+![conda_prompt](./images/conda_env_1.png)
+
+运行之后，如果你能看到命令行窗口前面有一个(base)字样，说明你成功进入了`conda`环境。那么你就可以执行以下命令了。
+
+![conda_env](./images/conda_env_2.png)
+
+```
+conda remove -n xiaozhi-esp32-server --all -y
+conda create -n xiaozhi-esp32-server python=3.10 -y
+conda activate xiaozhi-esp32-server
+
+# 添加清华源通道
+conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
+conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free
+conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge
+
+conda install libopus -y
+conda install ffmpeg -y
+```
+
+请注意，以上命令，不是一股脑执行就成功的，你需要一步步执行，每一步执行完后，都检查一下输出的日志，查看是否成功。
+
+## 6.安装本项目依赖
+
+你先要下载本项目源码，源码可以通过`git clone`命令下载，如果你不熟悉`git clone`命令。
+
+你可以用浏览器打开这个地址`https://github.com/xinnan-tech/xiaozhi-esp32-server.git`
+
+打开完，找到页面中一个绿色的按钮，写着`Code`的按钮，点开它，然后你就看到`Download ZIP`的按钮。
+
+点击它，下载本项目源码压缩包。下载到你电脑后，解压它，此时它的名字可能叫`xiaozhi-esp32-server-main`
+你需要把它重命名成`xiaozhi-esp32-server`，在这个文件里，进入到`main`文件夹，再进入到`xiaozhi-server`，好了请记住这个目录`xiaozhi-server`。
+
+```
+# 继续使用conda环境
+conda activate xiaozhi-esp32-server
+# 进入到你的项目根目录，再进入main/xiaozhi-server
+cd main/xiaozhi-server
+pip config set global.index-url https://mirrors.aliyun.com/pypi/simple/
+pip install -r requirements.txt
+```
+
+### 7.下载语音识别模型文件
+
+本项目语音识别模型，默认使用`SenseVoiceSmall`模型，进行语音转文字。因为模型较大，需要独立下载，下载后把`model.pt`
+文件放在`models/SenseVoiceSmall`
+目录下。下面两个下载路线任选一个。
+
+- 线路一：阿里魔塔下载[SenseVoiceSmall](https://modelscope.cn/models/iic/SenseVoiceSmall/resolve/master/model.pt)
+- 线路二：百度网盘下载[SenseVoiceSmall](https://pan.baidu.com/share/init?surl=QlgM58FHhYv1tFnUT_A8Sg&pwd=qvna) 提取码:
+  `qvna`
+
+## 8.配置项目文件
+
+使用超级管理员账号，登录智控台 ，在顶部菜单找到`参数管理`，找到列表中第一条数据，参数编码是`server.secret`，复制它到`参数值`。
+
+`server.secret`需要说明一下，这个`参数值`很重要，作用是让我们的`Server`端连接`manager-api`。`server.secret`是每次从零部署manager模块时，会自动随机生成的密钥。
+
+如果你的`xiaozhi-server`目录没有`data`，你需要创建`data`目录。
+如果你的`data`下面没有`.config.yaml`文件，你可以把`xiaozhi-server`目录下的`config_from_api.yaml`文件复制到`data`，并重命名为`.config.yaml`
+
+复制`参数值`后，打开`xiaozhi-server`下的`data`目录的`.config.yaml`文件。此刻你的配置文件内容应该是这样的：
+
+```
+manager-api:
+  url: http://127.0.0.1:8002/xiaozhi
+  secret: 你的server.secret值
+```
+
+把你刚才从`智控台`复制过来的`server.secret`的`参数值`复制到`.config.yaml`文件里的`secret`里。
+
+类似这样的效果
+```
+manager-api:
+  url: http://127.0.0.1:8002/xiaozhi
+  secret: 12345678-xxxx-xxxx-xxxx-123456789000
+```
+
+## 5.运行项目
+
+```
+# 确保在xiaozhi-server目录下执行
+conda activate xiaozhi-esp32-server
+python app.py
+```
+
+如果你能看到，类似以下日志,则是本项目服务启动成功的标志。
+
+```
+25-02-23 12:01:09[core.websocket_server] - INFO - Server is running at ws://xxx.xx.xx.xx:8000/xiaozhi/v1/
+25-02-23 12:01:09[core.websocket_server] - INFO - =======上面的地址是websocket协议地址，请勿用浏览器访问=======
+25-02-23 12:01:09[core.websocket_server] - INFO - 如想测试websocket请用谷歌浏览器打开test目录下的test_page.html
+25-02-23 12:01:09[core.websocket_server] - INFO - =======================================================
+```
+
+由于你是全模块部署，因此你有两个重要的接口。
+
+OTA接口：
+```
+http://你电脑局域网的ip:8002/xiaozhi/ota/
+```
+
+Websocket接口：
+```
+ws://你电脑局域网的ip:8000/xiaozhi/v1/
+```
+
+请你务必把以上两个接口地址写入到智控台中：他们将会影响websocket地址发放和自动升级功能。
+
+1、使用超级管理员账号，登录智控台，在顶部菜单找到`参数管理`，找到参数编码是`server.websocket`，输入你的`Websocket接口`。
+
+2、使用超级管理员账号，登录智控台，在顶部菜单找到`参数管理`，找到数编码是`server.ota`，输入你的`OTA接口`。
+
+
+接下来，你就可以开始操作你的esp32设备了，你可以`自行编译esp32固件`也可以配置使用`虾哥编译好的1.6.1以上版本的固件`。两个任选一个
+
+1、 [编译自己的esp32固件](firmware-build.md)了。
+
+2、 [基于虾哥编译好的固件配置自定义服务器](firmware-setting.md)了。
+
+# 常见问题
+
+以下是一些常见问题，供参考：
+
+[1、为什么我说的话，小智识别出来很多韩文、日文、英文](./FAQ.md)
+
+[2、为什么会出现“TTS 任务出错 文件不存在”？](./FAQ.md)
+
+[3、TTS 经常失败，经常超时](./FAQ.md)
+
+[4、使用Wifi能连接自建服务器，但是4G模式却接不上](./FAQ.md)
+
+[5、如何提高小智对话响应速度？](./FAQ.md)
+
+[6、我说话很慢，停顿时小智老是抢话](./FAQ.md)
+
+[7、我想通过小智控制电灯、空调、远程开关机等操作](./FAQ.md)

docs/FAQ.md

@@ -0,0 +1,111 @@
+# 常见问题 ❓
+
+### 1、为什么我说的话，小智识别出来很多韩文、日文、英文？🇰🇷
+
+建议：检查一下`models/SenseVoiceSmall`是否已经有`model.pt`
+文件，如果没有就要下载，查看这里[下载语音识别模型文件](Deployment.md#模型文件)
+
+### 2、为什么会出现"TTS 任务出错 文件不存在"？📁
+
+建议：检查一下是否正确使用`conda` 安装了`libopus`和`ffmpeg`库。
+
+如果没有安装，就安装
+
+```
+conda install conda-forge::libopus
+conda install conda-forge::ffmpeg
+```
+
+### 3、TTS 经常失败，经常超时 ⏰
+
+建议：如果 `EdgeTTS` 经常失败，请先检查是否使用了代理（梯子）。如果使用了，请尝试关闭代理后再试；  
+如果用的是火山引擎的豆包 TTS，经常失败时建议使用付费版本，因为测试版本仅支持 2 个并发。
+
+### 4、使用Wifi能连接自建服务器，但是4G模式却接不上 🔐
+
+原因：虾哥的固件，4G模式需要使用安全连接。
+
+解决方法：目前有两种方法可以解决。任选一种：
+
+1、改代码。参考这个视频解决 https://www.bilibili.com/video/BV18MfTYoE85
+
+2、使用nginx配置ssl证书。参考教程 https://icnt94i5ctj4.feishu.cn/docx/GnYOdMNJOoRCljx1ctecsj9cnRe
+
+### 5、如何提高小智对话响应速度？ ⚡
+
+本项目默认配置为低成本方案，建议初学者先使用默认免费模型，解决"跑得动"的问题，再优化"跑得快"。  
+如需提升响应速度，可尝试更换各组件。以下为各组件的响应速度测试数据（仅供参考，不构成承诺）：
+
+| 影响因素  |       因素值        | 
+|:-----:|:----------------:|
+| 测试地点  |    广东省广州市海珠区     |
+| 测试时间  | 2025年2月19日 12:52 |
+| 宽带运营商 |       中国联通       |
+
+测试方法：
+
+1、把各组件的密钥配置上去，只有配置了密钥的组件才参与测试。
+
+2、配置完密钥后，执行以下方法
+
+```
+# 进入项目根目录，执行以下命令：
+conda activate xiaozhi-esp32-server
+python performance_tester.py 
+```
+
+生成报告如下
+
+LLM 性能排行:
+
+| 模块名称       | 平均首Token时间 | 平均总响应时间 |
+|:-----------|:-----------|:--------|
+| AliLLM     | 0.547s     | 1.485s  |
+| ChatGLMLLM | 0.677s     | 3.057s  |
+
+TTS 性能排行:
+
+| 模块名称                 | 平均合成时间 |
+|----------------------|--------|
+| EdgeTTS              | 1.019s |
+| DoubaoTTS            | 0.503s |
+| CosyVoiceSiliconflow | 3.732s |
+
+推荐配置组合 (综合响应速度):
+
+| 组合方案                          | 综合得分  | LLM首Token | TTS合成  |
+|-------------------------------|-------|-----------|--------|
+| AliLLM + DoubaoTTS            | 0.539 | 0.547s    | 0.503s |
+| AliLLM + EdgeTTS              | 0.642 | 0.547s    | 1.019s |
+| ChatGLMLLM + DoubaoTTS        | 0.642 | 0.677s    | 0.503s |
+| ChatGLMLLM + EdgeTTS          | 0.745 | 0.677s    | 1.019s |
+| AliLLM + CosyVoiceSiliconflow | 1.184 | 0.547s    | 3.732s |
+
+### 结论 🔍
+
+`2025年2月19日`，如果我的电脑在`广东省广州市海珠区`，且使用的是`中国联通`网络，我会优先使用：
+
+- LLM：`AliLLM`
+- TTS：`DoubaoTTS`
+
+### 6、我说话很慢，停顿时小智老是抢话 🗣️
+
+建议：在配置文件中找到如下部分，将 `min_silence_duration_ms` 的值调大（例如改为 `1000`）：
+
+```yaml
+VAD:
+  SileroVAD:
+    threshold: 0.5
+    model_dir: models/snakers4_silero-vad
+    min_silence_duration_ms: 700  # 如果说话停顿较长，可将此值调大
+```
+
+### 7、我想通过小智控制电灯、空调、远程开关机等操作 💡
+
+参考教程[ESP32设备与HomeAssistant集成指南](./homeassistant-integration.md)
+
+### 8、更多问题，可联系我们反馈 💬
+
+可以在[issues](https://github.com/xinnan-tech/xiaozhi-esp32-server/issues)提交您的问题。
+
+也可以发邮件我们取得联系：huangrongzhuang@xin-nan.com

docs/docker/nginx.conf

@@ -1,26 +1,53 @@
-server {
-    listen 8002;
-    server_name localhost;
+user  root;
+worker_processes  4;
 
-    # 静态资源服务（Vue项目）
-    location / {
-        root /usr/share/nginx/html;
-        try_files $uri $uri/ /index.html;
-    }
+events {
+    worker_connections  1024;
+}
 
-    # API反向代理（Java项目）
-    location /xiaozhi-esp32-api/ {
-        proxy_pass http://127.0.0.1:8003;
-        proxy_set_header   Host   $host;
-        proxy_cookie_path /api/ /;
-        proxy_set_header   Referer $http_referer;
-        proxy_set_header   Cookie $http_cookie;
+http {
+    include       mime.types;
+    default_type  application/octet-stream;
+    sendfile        on;
+    keepalive_timeout  300;
+    client_header_timeout 180s;
+    client_body_timeout 180s;
+    client_max_body_size 1024M;
 
-        proxy_connect_timeout 10;
-        proxy_send_timeout 10;
-        proxy_read_timeout 10;
+    gzip on;
+    gzip_buffers 32 4K;
+    gzip_comp_level 6;
+    gzip_min_length 100;
+    gzip_types application/javascript text/css text/xml image/jpeg image/gif image/png;
+    gzip_disable "MSIE [1-6]\.";
+    gzip_vary on;
 
-        proxy_set_header   X-Real-IP  $remote_addr;
-        proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
+    server {
+        # 无域名访问，就用localhost
+        server_name localhost;
+        # 80端口
+        listen  8002;
+
+        # 转发到编译后到web目录
+        location / {
+			root /usr/share/nginx/html;
+			try_files $uri $uri/ /index.html;
+		}
+
+        # 转发到manager-api
+        location /xiaozhi/ {
+            proxy_pass http://127.0.0.1:8003;
+            proxy_set_header   Host   $host;
+            proxy_cookie_path /manager/ /;
+            proxy_set_header   Referer $http_referer;
+            proxy_set_header   Cookie $http_cookie;
+
+            proxy_connect_timeout 10;
+            proxy_send_timeout 10;
+            proxy_read_timeout 10;
+
+            proxy_set_header   X-Real-IP  $remote_addr;
+            proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
+        }
     }
 }

docs/firmware-build.md

@@ -1,40 +1,81 @@
-# 编译esp32固件
+# esp32固件编译
 
-1. 下载`xiaozhi-esp32`
-   项目，按照这个教程配置项目环境[《Windows搭建 ESP IDF 5.3.2开发环境以及编译小智》](https://icnynnzcwou8.feishu.cn/wiki/JEYDwTTALi5s2zkGlFGcDiRknXf)
+## 第1步 准备你的ota地址
 
-2. 打开`xiaozhi-esp32/main/Kconfig.projbuild`文件，找到`WEBSOCKET_URL`的`default`的内容，把`wss://api.tenclass.net`
-   改成你自己的地址，例如，我的接口地址是`ws://192.168.1.25:8000`，就把内容改成这个。
+如果你，使用的是本项目0.3.12版本，不管是简单Server部署还是全模块部署，都会有ota地址。
+
+由于简单Server部署和全模块部署的OTA地址设置方式不一样，请你选择下面的具体方式：
+
+### 如果你用的是简单Server部署
+此刻，请你用浏览器打开你的ota地址，例如我的ota地址
+```
+http://192.168.1.25:8002/xiaozhi/ota/
+```
+如果显示“OTA接口运行正常，向设备发送的websocket地址是：ws://xxx:8000/xiaozhi/v1/
+
+你可以使用项目自带的`test_page.html`测试一下，是否能连上ota页面输出的websocket地址。
+
+如果访问不到，你需要到配置文件`.config.yaml`里修改`server.websocket`的地址，重启后再重新测试，直到`test_page.html`能正常访问。
+
+成功后，请往下进行第2步
+
+### 如果你用的是全模块部署
+此刻，请你用浏览器打开你的ota地址，例如我的ota地址
+```
+http://192.168.1.25:8002/xiaozhi/ota/
+```
+
+如果显示“OTA接口运行正常，websocket集群数量：X”。那就往下进行2步。
+
+如果显示“OTA接口运行不正常”，大概是你还没在`智控台`配置`Websocket`地址。那就：
+
+- 1、使用超级管理员登录智控台
+
+- 2、顶部菜单点击`参数管理`
+
+- 3、在列表中找到`server.websocket`项目，输入你的`Websocket`地址。例如我的就是
+
+```
+ws://192.168.1.25:8000/xiaozhi/v1/
+```
+
+配置完后，再使用浏览器刷新你的ota接口地址，看看是不是正常了。如果还不正常就，就再次确认一下Websocket是否正常启动，是否配置了Websocket地址。
+
+## 第2步 配置环境
+先按照这个教程配置项目环境[《Windows搭建 ESP IDF 5.3.2开发环境以及编译小智》](https://icnynnzcwou8.feishu.cn/wiki/JEYDwTTALi5s2zkGlFGcDiRknXf)
+
+## 第3步 打开配置文件
+配置好编译环境后，下载虾哥iaozhi-esp32项目源码，
+
+从这里下载虾哥[xiaozhi-esp32项目源码](https://github.com/78/xiaozhi-esp32)。
+
+下载后，打开`xiaozhi-esp32/main/Kconfig.projbuild`文件。
+
+## 第4步 修改OTA地址
+
+找到`OTA_URL`的`default`的内容，把`https://api.tenclass.net/xiaozhi/ota/`
+   改成你自己的地址，例如，我的接口地址是`http://192.168.1.25:8002/xiaozhi/ota/`，就把内容改成这个。
 
 修改前：
-
 ```
-config WEBSOCKET_URL
-    depends on CONNECTION_TYPE_WEBSOCKET
-    string "Websocket URL"
-    default "wss://api.tenclass.net/xiaozhi/v1/"
+config OTA_URL
+    string "Default OTA URL"
+    default "https://api.tenclass.net/xiaozhi/ota/"
     help
-        Communication with the server through websocket after wake up.
+        The application will access this URL to check for new firmwares and server address.
 ```
-
-修改后(示例)：
-
+修改后：
 ```
-config WEBSOCKET_URL
-    depends on CONNECTION_TYPE_WEBSOCKET
-    string "Websocket URL"
-    default "ws://192.168.1.25:8000/xiaozhi/v1/"
+config OTA_URL
+    string "Default OTA URL"
+    default "http://192.168.1.25:8002/xiaozhi/ota/"
     help
-        Communication with the server through websocket after wake up.
+        The application will access this URL to check for new firmwares and server address.
 ```
 
-注意：你的地址是`ws://`开头，不是`wss://`开头，一定不要写错了。
+## 第4步 设置编译参数
 
-注意：你的地址是`ws://`开头，不是`wss://`开头，一定不要写错了。
-
-注意：你的地址是`ws://`开头，不是`wss://`开头，一定不要写错了。
-
-3. 设置编译参数
+设置编译参数
 
 ```
 # 终端命令行进入xiaozhi-esp32的根目录
@@ -45,40 +86,29 @@ idf.py set-target esp32s3
 idf.py menuconfig
 ```
 
-![图片](images/build_setting01.png)
-
-进入菜单配置后，再进入`Xiaozhi Assistant`，将`CONNECTION_TYPE`设置为`Websocket`
-回退到主菜单，再进入`Xiaozhi Assistant`，将`BOARD_TYPE`设置你板子的具体型号
+进入菜单配置后，再进入`Xiaozhi Assistant`，将`BOARD_TYPE`设置你板子的具体型号
 保存退出，回到终端命令行。
 
-![图片](images/build_setting02.png)
-
-4. 编译固件
+## 第5步 编译固件
 
 ```
 idf.py build
 ```
 
-如果是vscode安装的idf可以使用`F1`或者`ctrl+shift+p`,输入idf然后直接选择进行编译
-
-还可以直接进行烧录不用接下来的操作
-
-<img src="./images/vscode_idf.png" width="500px"/>
-
-5. 打包bin固件
+## 第6步 打包bin固件
 
 ```
 cd scripts
 python release.py
 ```
 
-编译成功后，会在项目根目录下的`build`目录下生成固件文件`merged-binary.bin`。
+上面的打包命令执行完成后，会在项目根目录下的`build`目录下生成固件文件`merged-binary.bin`。
 这个`merged-binary.bin`就是要烧录到硬件上的固件文件。
 
 注意：如果执行到第二命令后，报了“zip”相关的错误，请忽略这个错误，只要`build`目录下生成固件文件`merged-binary.bin`
 ，对你没有太大影响，请继续。
 
-6. 烧录固件
+## 第7步 烧录固件
    将esp32设备连接电脑，使用chrome浏览器，打开以下网址
 
 ```
@@ -90,16 +120,19 @@ https://espressif.github.io/esp-launchpad/
 
 烧录成功且联网成功后，通过唤醒词唤醒小智，留意server端输出的控制台信息。
 
+## 常见问题
 以下是一些常见问题，供参考：
 
-[1、为什么我说的话，小智识别出来很多韩文、日文、英文](../README.md#1tts-%E7%BB%8F%E5%B8%B8%E5%A4%B1%E8%B4%A5%E7%BB%8F%E5%B8%B8%E8%B6%85%E6%97%B6-)
+[1、为什么我说的话，小智识别出来很多韩文、日文、英文](./FAQ.md)
 
-[2、为什么会出现“TTS 任务出错 文件不存在”？](../README.md#1tts-%E7%BB%8F%E5%B8%B8%E5%A4%B1%E8%B4%A5%E7%BB%8F%E5%B8%B8%E8%B6%85%E6%97%B6-)
+[2、为什么会出现“TTS 任务出错 文件不存在”？](./FAQ.md)
 
-[3、TTS 经常失败，经常超时](../README.md#1tts-%E7%BB%8F%E5%B8%B8%E5%A4%B1%E8%B4%A5%E7%BB%8F%E5%B8%B8%E8%B6%85%E6%97%B6-)
+[3、TTS 经常失败，经常超时](./FAQ.md)
 
-[4、如何提高小智对话响应速度？](../README.md#1tts-%E7%BB%8F%E5%B8%B8%E5%A4%B1%E8%B4%A5%E7%BB%8F%E5%B8%B8%E8%B6%85%E6%97%B6-)
+[4、使用Wifi能连接自建服务器，但是4G模式却接不上](./FAQ.md)
 
-[5、我说话很慢，停顿时小智老是抢话](../README.md#1tts-%E7%BB%8F%E5%B8%B8%E5%A4%B1%E8%B4%A5%E7%BB%8F%E5%B8%B8%E8%B6%85%E6%97%B6-)
+[5、如何提高小智对话响应速度？](./FAQ.md)
 
-[6、我想通过小智控制电灯、空调、远程开关机等操作](../README.md#1tts-%E7%BB%8F%E5%B8%B8%E5%A4%B1%E8%B4%A5%E7%BB%8F%E5%B8%B8%E8%B6%85%E6%97%B6-)
+[6、我说话很慢，停顿时小智老是抢话](./FAQ.md)
+
+[7、我想通过小智控制电灯、空调、远程开关机等操作](./FAQ.md)

docs/firmware-setting.md

@@ -0,0 +1,53 @@
+# 基于虾哥编译好的固件配置自定义服务器
+
+## 第1步 确认版本
+烧录虾哥已经编译好的1.6.1版本固件
+
+## 第2步 准备你的ota地址
+如果你按照教程使用的是全模块部署，就应该会有ota地址。
+
+此刻，请你用浏览器打开你的ota地址，例如我的ota地址
+```
+https://2662r3426b.vicp.fun/xiaozhi/ota/
+```
+
+如果显示“OTA接口运行正常，websocket集群数量：X”。那就往下。
+
+如果显示“OTA接口运行不正常”，大概是你还没在`智控台`配置`Websocket`地址。那就：
+
+- 1、使用超级管理员登录智控台
+
+- 2、顶部菜单点击`参数管理`
+
+- 3、在列表中找到`server.websocket`项目，输入你的`Websocket`地址。例如我的就是
+
+```
+wss://2662r3426b.vicp.fun/xiaozhi/v1/
+```
+
+配置完后，再使用浏览器刷新你的ota接口地址，看看是不是正常了。如果还不正常就，就再次确认一下Websocket是否正常启动，是否配置了Websocket地址。
+
+## 第3步 进入配网模式
+进入机器的配网模式，在页面顶部，点击“高级选项”，在里面输入你服务器的`ota`地址，点击保存。重启设备
+
+## 第4步 唤醒小智，查看日志输出
+
+唤醒小智，看看日志是不是正常输出。
+
+
+## 常见问题
+以下是一些常见问题，供参考：
+
+[1、为什么我说的话，小智识别出来很多韩文、日文、英文](./FAQ.md)
+
+[2、为什么会出现“TTS 任务出错 文件不存在”？](./FAQ.md)
+
+[3、TTS 经常失败，经常超时](./FAQ.md)
+
+[4、使用Wifi能连接自建服务器，但是4G模式却接不上](./FAQ.md)
+
+[5、如何提高小智对话响应速度？](./FAQ.md)
+
+[6、我说话很慢，停顿时小智老是抢话](./FAQ.md)
+
+[7、我想通过小智控制电灯、空调、远程开关机等操作](./FAQ.md)

docs/homeassistant-integration.md

@@ -0,0 +1,111 @@
+# ESP32设备与HomeAssistant集成指南
+
+## 简介
+
+本文档将指导您如何将ESP32设备与HomeAssistant进行集成。
+
+## 前提条件
+
+- 已安装并配置好`HomeAssistant`
+- 已经在HomeAssistant中集成`Xiaomi Home`，并将米家的设备导入进`HomeAssistant`
+- `xiaozhi-esp32-server智控台`能正常使用
+- 本次我选择的模型是：免费的ChatGLM，它支持functioncall函数调用
+
+## 网络环境
+
+1、我的`HomeAssistant`部署在下面，版本是`2025.3.4`
+```
+http://192.168.4.7:8123
+```
+
+2、我的`xiaozhi-esp32-server智控台`和`HomeAssistant`部署在同一台机器的另一个端口，版本是`0.3.10`
+```
+http://192.168.4.7:8002
+```
+
+
+## 配置步骤
+
+### 1. 登录`HomeAssistant`整理需要控制的设备清单
+
+登录`HomeAssistant`，点击`左下角的设置`，然后进入`设备与服务`，再点击顶部的`实体`。
+
+然后在实体中搜索你相关控制的开关，结果出来后，在列表中，点击其中一个结果，这是会出现一个开关的界面。
+
+在开关的界面，我们尝试点击开关，看看是开发会随着我们的点击开/关。如果能操作，说明是正常联网的。
+
+接着在开关面板找到设置按钮，点击后，可以查看这个开关的`实体标识符`。
+
+我们打开一个记事本，按照这样格式整理一条数据：
+
+位置+英文逗号+设备名称+英文逗号+`实体标识符`+英文分号
+
+例如，我在公司，我有一个玩具灯，他的标识符是switch.cuco_cn_460494544_cp1_on_p_2_1，那么就这个写这一条数据
+
+```
+公司,玩具灯,switch.cuco_cn_460494544_cp1_on_p_2_1;
+```
+
+当然最后我可能要操作两个灯，我的最终的结果是：
+
+```
+公司,玩具灯,switch.cuco_cn_460494544_cp1_on_p_2_1;
+公司,台灯,switch.iot_cn_831898993_socn1_on_p_2_1;
+```
+
+这段字符，我们成为“设备清单字符”需要保存好，等一下有用。
+
+
+### 2. 登录`HomeAssistant`拿到开发密钥
+
+登录`HomeAssistant`，点击`左下角个人`，切换`安全`导航栏，划到底部`长期访问令牌`生成api_key。
+
+
+### 3. 登录`智控台`
+
+使用管理员账号，登录`智控台`。点击顶部菜单`参数管理`，搜索`plugins.home_assistant.`，会有三条结果出来
+
+编辑`plugins.home_assistant.devices`，把刚才整理的设备清单字符粘贴进去。
+
+
+编辑`plugins.home_assistant.base_url`，把你部署的`HomeAssistant`接口地址粘贴进去，我粘贴进去的地址是这样的
+
+```
+http://192.168.4.7:8123
+```
+
+编辑`plugins.home_assistant.api_key`，把你从`HomeAssistant`复制过来的密钥，粘贴进去
+
+
+### 4. 设置`意图识别`函数
+
+在智控台，点击顶部菜单“模型配置”，在左侧栏，找到“意图识别”，找到id为`Intent_function_call`的意图，点击编辑
+
+然后在弹框中，在原来的基础上追加两个函数：“hass_get_state”和“hass_set_state”
+
+修改前
+```
+change_role;get_weather;get_news;play_music
+```
+
+修改后
+
+```
+change_role;get_weather;get_news;play_music;hass_get_state;hass_set_state
+```
+
+### 6. 手动重启xiaozhi-server
+
+重启xiaozhi-server程序
+
+
+### 5. 确认角色配置是否设置了函数意图识别
+
+在智控台，点击顶部菜单“智能体管理”，找到设备所在的智能体，点击“配置角色”
+
+确认意图识别(Intent)，是否选择“函数调用意图识别”
+
+
+### 6. 唤醒设别进行控制
+
+尝试和esp32说，“打开XXX灯”

main/README.md

@@ -1,8 +1,6 @@
-本文档是开发类文档，如需部署小智服务端，[点击这里查看部署教程](../README.md#%E4%BD%BF%E7%94%A8%E6%96%B9%E5%BC%8F-)
+本文档是开发类文档，如需部署小智服务端，[点击这里查看部署教程](../README.md#%E9%83%A8%E7%BD%B2%E6%96%87%E6%A1%A3)
 
 # 项目目录介绍
-当你看到这份文件的时候，这个这个项目还没完善好。我们还有很多东西要做。
-
 如果你是一名软件开发者，这里有一份[《致开发者的公开信》](../docs/contributor_open_letter.md)，欢迎归队！
 
 ```
@@ -12,10 +10,10 @@ xiaozhi-esp32-server
   ├─ manager-api 8002 端口 Java语言开发 负责提供控制台的api
 ```
 
-# xiaozhi-server 接口协议
+# xiaozhi-server 和ESP32通讯协议
 
-[虾哥团队通信协议：Websocket 连接](https://ccnphfhqs21z.feishu.cn/wiki/M0XiwldO9iJwHikpXD5cEx71nKh)
+https://ccnphfhqs21z.feishu.cn/wiki/M0XiwldO9iJwHikpXD5cEx71nKh
 
 # manager-web 、manager-api接口协议
 
-https://2662r3426b.vicp.fun/xiaozhi-esp32-api/api/v1/doc.html
+https://2662r3426b.vicp.fun/xiaozhi/doc.html

main/manager-api/README.md

@@ -1,4 +1,5 @@
-本文档是开发类文档，如需部署小智服务端，[点击这里查看部署教程](../../README.md#%E4%BD%BF%E7%94%A8%E6%96%B9%E5%BC%8F-)
+本文档是开发类文档，如需部署小智服务端，[点击这里查看部署教程](../../README.md#%E9%83%A8%E7%BD%B2%E6%96%87%E6%A1%A3)
+
 # 项目介绍
 
 manager-api 该项目基于SpringBoot框架开发。
@@ -12,85 +13,6 @@ MySQL 8.0+
 Redis 5.0+
 Vue 3.x
 
-# 创建数据库
-
-如果本机已经安装了MySQL，可以直接在数据库中创建名为`xiaozhi_esp32_server`的数据库。
-
-```sql
-CREATE DATABASE xiaozhi_esp32_server CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
-```
-
-如果还没有MySQL，你可以通过docker安装mysql
-
-```
-docker run --name xiaozhi-esp32-server-db \
--e MYSQL_ROOT_PASSWORD=123456 \
--p 3306:3306 \
--e MYSQL_DATABASE=xiaozhi_esp32_server \
--e MYSQL_INITDB_ARGS="--character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci" \
--d mysql:latest
-```
-
-# 确认项目数据库连接信息
-
-在`src/main/resources/application-dev.yml`中配置数据库连接信息
-
-```
-spring:
-  datasource:
-    username: root
-    password: 123456
-```
-
-
-# 连接Redis
-
-如果还没有Redis，你可以通过docker安装redis
-
-```
-docker run --name xiaozhi-esp32-server-redis -d -p 6379:6379 redis
-```
-
-# 确认项目Redis连接信息
-
-在`src/main/resources/application-dev.yml`中配置Redis连接信息
-
-```
-spring:
-    data:
-      redis:
-        host: localhost
-        port: 6379
-        password:
-        database: 0
-```
-
-
-# 测试启动
-
-本项目为SpringBoot项目，启动方式为：
-打开`Application.java`运行`Main`方法启动
-
-```
-路径地址：
-src/main/java/xiaozhi/AdminApplication.java
-```
-
-# 打包编译
-
-执行以下命令生产jar包
-
-```
-mvn clean install
-```
-
-把jar包放在服务器上，执行
-
-```
-nohup java -jar xiaozhi-esp32-api.jar --spring.profiles.activate=dev
-```
-
-
 # 接口文档
-启动后打开：http://localhost:8002/xiaozhi-esp32-api/doc.html
+启动后打开：http://localhost:8002/xiaozhi/doc.html
 

main/manager-api/pom.xml

@@ -197,6 +197,10 @@
             <artifactId>lombok</artifactId>
             <optional>true</optional>
         </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.datatype</groupId>
+            <artifactId>jackson-datatype-jsr310</artifactId>
+        </dependency>
     </dependencies>
 
     <!-- 阿里云maven仓库 -->

main/manager-api/src/main/java/xiaozhi/AdminApplication.java

@@ -8,6 +8,6 @@ public class AdminApplication {
 
     public static void main(String[] args) {
         SpringApplication.run(AdminApplication.class, args);
-        System.out.println("http://localhost:8002/xiaozhi-esp32-api/api/v1/doc.html");
+        System.out.println("http://localhost:8002/xiaozhi/doc.html");
     }
 }

main/manager-api/src/main/java/xiaozhi/common/config/RestTemplateConfig.java

@@ -0,0 +1,17 @@
+package xiaozhi.common.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.client.RestTemplate;
+
+/**
+ * RestTemplate配置
+ */
+@Configuration
+public class RestTemplateConfig {
+
+    @Bean
+    public RestTemplate restTemplate() {
+        return new RestTemplate();
+    }
+}

main/manager-api/src/main/java/xiaozhi/common/config/SwaggerConfig.java

@@ -51,7 +51,7 @@ public class SwaggerConfig {
     public GroupedOpenApi timbreApi() {
         return GroupedOpenApi.builder()
                 .group("timbre")
-                .pathsToMatch("/timbre/**")
+                .pathsToMatch("/ttsVoice/**")
                 .build();
     }
 
@@ -71,6 +71,14 @@ public class SwaggerConfig {
                 .build();
     }
 
+    @Bean
+    public GroupedOpenApi configApi() {
+        return GroupedOpenApi.builder()
+                .group("config")
+                .pathsToMatch("/config/**")
+                .build();
+    }
+
     @Bean
     public OpenAPI customOpenAPI() {
         return new OpenAPI().info(new Info()

main/manager-api/src/main/java/xiaozhi/common/constant/Constant.java

@@ -74,8 +74,36 @@ public interface Constant {
      */
     String ORDER = "order";
 
+    /**
+     * 请求头授权标识
+     */
     String AUTHORIZATION = "Authorization";
 
+    /**
+     * 服务器密钥
+     */
+    String SERVER_SECRET = "server.secret";
+
+    /**
+     * websocket地址
+     */
+    String SERVER_WEBSOCKET = "server.websocket";
+
+    /**
+     * ota地址
+     */
+    String SERVER_OTA = "server.ota";
+
+    /**
+     * 是否允许用户注册
+     */
+    String SERVER_ALLOW_USER_REGISTER = "server.allow_user_register";
+
+    /**
+     * 下发六位验证码时显示的控制面板地址
+     */
+    String SERVER_FRONTED_URL = "server.fronted_url";
+
     /**
      * 路径分割符
      */
@@ -145,4 +173,9 @@ public interface Constant {
             return value;
         }
     }
+
+    /**
+     * 版本号
+     */
+    public static final String VERSION = "0.4.2";
 }

main/manager-api/src/main/java/xiaozhi/common/exception/ErrorCode.java

@@ -43,4 +43,16 @@ public interface ErrorCode {
     int PASSWORD_WEAK_ERROR = 10031;
     int DEL_MYSELF_ERROR = 10032;
     int DEVICE_CAPTCHA_ERROR = 10033;
+
+    // 参数校验相关错误码
+    int PARAM_VALUE_NULL = 10034;
+    int PARAM_TYPE_NULL = 10035;
+    int PARAM_TYPE_INVALID = 10036;
+    int PARAM_NUMBER_INVALID = 10037;
+    int PARAM_BOOLEAN_INVALID = 10038;
+    int PARAM_ARRAY_INVALID = 10039;
+    int PARAM_JSON_INVALID = 10040;
+
+    int OTA_DEVICE_NOT_FOUND = 10041;
+    int OTA_DEVICE_NEED_BIND = 10042;
 }

main/manager-api/src/main/java/xiaozhi/common/exception/RenExceptionHandler.java

@@ -4,6 +4,7 @@ import org.apache.shiro.authz.UnauthorizedException;
 import org.springframework.dao.DuplicateKeyException;
 import org.springframework.web.bind.annotation.ExceptionHandler;
 import org.springframework.web.bind.annotation.RestControllerAdvice;
+import org.springframework.web.servlet.resource.NoResourceFoundException;
 
 import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -53,4 +54,10 @@ public class RenExceptionHandler {
         return new Result<Void>().error();
     }
 
+    @ExceptionHandler(NoResourceFoundException.class)
+    public Result<Void> handleNoResourceFoundException(NoResourceFoundException ex) {
+        log.warn("Resource not found: {}", ex.getMessage());
+        return new Result<Void>().error(404, "资源不存在");
+    }
+
 }

main/manager-api/src/main/java/xiaozhi/common/redis/RedisKeys.java

@@ -26,4 +26,95 @@ public class RedisKeys {
     public static String getDeviceCaptchaKey(String captcha) {
         return "sys:device:captcha:" + captcha;
     }
+
+    /**
+     * 用户id的Key
+     */
+    public static String getUserIdKey(Long userid) {
+        return "sys:username:id:" + userid;
+    }
+
+    /**
+     * 模型名称的Key
+     */
+    public static String getModelNameById(String id) {
+        return "model:name:" + id;
+    }
+
+    /**
+     * 模型配置的Key
+     */
+    public static String getModelConfigById(String id) {
+        return "model:data:" + id;
+    }
+
+    /**
+     * 获取音色名称缓存key
+     */
+    public static String getTimbreNameById(String id) {
+        return "timbre:name:" + id;
+    }
+
+    /**
+     * 获取设备数量缓存key
+     */
+    public static String getAgentDeviceCountById(String id) {
+        return "agent:device:count:" + id;
+    }
+
+    /**
+     * 获取智能体最后连接时间缓存key
+     */
+    public static String getAgentDeviceLastConnectedAtById(String id) {
+        return "agent:device:lastConnected:" + id;
+    }
+
+    /**
+     * 获取系统配置缓存key
+     */
+    public static String getServerConfigKey() {
+        return "server:config";
+    }
+
+    /**
+     * 获取音色详情缓存key
+     */
+    public static String getTimbreDetailsKey(String id) {
+        return "timbre:details:" + id;
+    }
+
+    /**
+     * 获取版本号Key
+     */
+    public static String getVersionKey() {
+        return "sys:version";
+    }
+
+    /**
+     * OTA固件ID的Key
+     */
+    public static String getOtaIdKey(String uuid) {
+        return "ota:id:" + uuid;
+    }
+
+    /**
+     * OTA固件下载次数的Key
+     */
+    public static String getOtaDownloadCountKey(String uuid) {
+        return "ota:download:count:" + uuid;
+    }
+
+    /**
+     * 获取字典数据的缓存key
+     */
+    public static String getDictDataByTypeKey(String dictType) {
+        return "sys:dict:data:" + dictType;
+    }
+
+    /**
+     * 获取智能体音频ID的缓存key
+     */
+    public static String getAgentAudioIdKey(String uuid) {
+        return "agent:audio:id:" + uuid;
+    }
 }

main/manager-api/src/main/java/xiaozhi/common/redis/RedisUtils.java

@@ -1,11 +1,14 @@
 package xiaozhi.common.redis;
 
 import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
 
 import org.springframework.data.redis.core.HashOperations;
 import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.core.script.DefaultRedisScript;
 import org.springframework.stereotype.Component;
 
 import jakarta.annotation.Resource;
@@ -27,7 +30,7 @@ public class RedisUtils {
     /**
      * 过期时长为1小时，单位：秒
      */
-    public final static long HOUR_ONE_EXPIRE = 60 * 60 * 1L;
+    public final static long HOUR_ONE_EXPIRE = (long) 60 * 60;
     /**
      * 过期时长为6小时，单位：秒
      */
@@ -124,4 +127,24 @@ public class RedisUtils {
     public Object rightPop(String key) {
         return redisTemplate.opsForList().rightPop(key);
     }
+
+
+    /**
+     * 清空所有 Redis 数据库中的所有键
+     */
+    public void emptyAll() {
+        // Lua 脚本 FLUSHALL是redis清空所有库的命令
+        String luaScript ="redis.call('FLUSHALL')";
+
+        // 创建 DefaultRedisScript 对象
+        DefaultRedisScript<Void> redisScript = new DefaultRedisScript<>();
+        redisScript.setScriptText(luaScript); // 设置 Lua 脚本内容
+        redisScript.setResultType(Void.class); // 设置返回值类型
+
+        // 执行 Lua 脚本
+        List<String> keys = Collections.emptyList(); // 如果脚本不依赖 key，可以传入空列表
+        redisTemplate.execute(redisScript, keys);
+
+    }
+
 }

main/manager-api/src/main/java/xiaozhi/common/service/impl/BaseServiceImpl.java

@@ -128,12 +128,10 @@ public abstract class BaseServiceImpl<M extends BaseMapper<T>, T> implements Bas
         return SqlHelper.retBool(result);
     }
 
-    @SuppressWarnings("unchecked")
     protected Class<M> currentMapperClass() {
         return (Class<M>) ReflectionKit.getSuperClassGenericType(this.getClass(), BaseServiceImpl.class, 0);
     }
 
-    @SuppressWarnings("unchecked")
     @Override
     public Class<T> currentModelClass() {
         return (Class<T>) ReflectionKit.getSuperClassGenericType(this.getClass(), BaseServiceImpl.class, 1);

main/manager-api/src/main/java/xiaozhi/common/service/impl/CrudServiceImpl.java

@@ -24,7 +24,6 @@ import xiaozhi.common.utils.ConvertUtils;
 public abstract class CrudServiceImpl<M extends BaseMapper<T>, T, D> extends BaseServiceImpl<M, T>
         implements CrudService<T, D> {
 
-    @SuppressWarnings("unchecked")
     protected Class<D> currentDtoClass() {
         return (Class<D>) ReflectionKit.getSuperClassGenericType(getClass(), CrudServiceImpl.class, 2);
     }

main/manager-api/src/main/java/xiaozhi/common/utils/DateUtils.java

@@ -2,6 +2,9 @@ package xiaozhi.common.utils;
 
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.temporal.ChronoUnit;
 import java.util.Date;
 
 /**
@@ -60,4 +63,39 @@ public class DateUtils {
         return null;
     }
 
+    /**
+     * 获取简短的时间字符串：10秒前返回刚刚，多少秒前，几小时前，超过一周返回年月日时分秒
+     * @param date
+     * @return
+     */
+    public static String getShortTime(Date date) {
+        if (date == null) {
+            return null;
+        }
+        // 将 Date 转换为 Instant
+        LocalDateTime localDateTime = date.toInstant()
+                // 获取系统默认时区
+                .atZone(ZoneId.systemDefault())
+                // 转换为 LocalDateTime
+                .toLocalDateTime();
+        // 当前时间
+        LocalDateTime now = LocalDateTime.now();
+        // 时间差，单位为秒
+        long secondsBetween = ChronoUnit.SECONDS.between(localDateTime, now);
+
+        if (secondsBetween <= 10) {
+            return "刚刚";
+        } else if (secondsBetween < 60) {
+            return secondsBetween + "秒前";
+        } else if (secondsBetween < 60 * 60) {
+            return secondsBetween / 60 + "分钟前";
+        } else if (secondsBetween < 86400) {
+            return secondsBetween / 3600 + "小时前";
+        } else if (secondsBetween < 604800) {
+            return secondsBetween / 86400 + "天前";
+        } else {
+            // 超过一周，显示完整日期时间
+            return format(date,DATE_TIME_PATTERN);
+        }
+    }
 }

main/manager-api/src/main/java/xiaozhi/modules/agent/controller/AgentChatHistoryController.java

@@ -0,0 +1,36 @@
+package xiaozhi.modules.agent.controller;
+
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import xiaozhi.common.utils.Result;
+import xiaozhi.modules.agent.dto.AgentChatHistoryReportDTO;
+import xiaozhi.modules.agent.service.biz.AgentChatHistoryBizService;
+
+@Tag(name = "智能体聊天历史管理")
+@RequiredArgsConstructor
+@RestController
+@RequestMapping("/agent/chat-history")
+public class AgentChatHistoryController {
+    private final AgentChatHistoryBizService agentChatHistoryBizService;
+
+    /**
+     * 小智服务聊天上报请求
+     * <p>
+     * 小智服务聊天上报请求，包含Base64编码的音频数据和相关信息。
+     *
+     * @param request 包含上传文件及相关信息的请求对象
+     */
+    @Operation(summary = "小智服务聊天上报请求")
+    @PostMapping("/report")
+    public Result<Boolean> uploadFile(@Valid @RequestBody AgentChatHistoryReportDTO request) {
+        Boolean result = agentChatHistoryBizService.report(request);
+        return new Result<Boolean>().ok(result);
+    }
+}

main/manager-api/src/main/java/xiaozhi/modules/agent/controller/AgentController.java

@@ -3,8 +3,13 @@ package xiaozhi.modules.agent.controller;
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
+import java.util.UUID;
 
+import org.apache.commons.lang3.StringUtils;
 import org.apache.shiro.authz.annotation.RequiresPermissions;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
@@ -25,15 +30,23 @@ import jakarta.validation.Valid;
 import lombok.AllArgsConstructor;
 import xiaozhi.common.constant.Constant;
 import xiaozhi.common.page.PageData;
+import xiaozhi.common.redis.RedisKeys;
+import xiaozhi.common.redis.RedisUtils;
 import xiaozhi.common.user.UserDetail;
 import xiaozhi.common.utils.ConvertUtils;
 import xiaozhi.common.utils.Result;
+import xiaozhi.modules.agent.dto.AgentChatHistoryDTO;
+import xiaozhi.modules.agent.dto.AgentChatSessionDTO;
 import xiaozhi.modules.agent.dto.AgentCreateDTO;
+import xiaozhi.modules.agent.dto.AgentDTO;
 import xiaozhi.modules.agent.dto.AgentUpdateDTO;
 import xiaozhi.modules.agent.entity.AgentEntity;
 import xiaozhi.modules.agent.entity.AgentTemplateEntity;
+import xiaozhi.modules.agent.service.AgentChatAudioService;
+import xiaozhi.modules.agent.service.AgentChatHistoryService;
 import xiaozhi.modules.agent.service.AgentService;
 import xiaozhi.modules.agent.service.AgentTemplateService;
+import xiaozhi.modules.device.service.DeviceService;
 import xiaozhi.modules.security.user.SecurityUser;
 
 @Tag(name = "智能体管理")
@@ -43,14 +56,18 @@ import xiaozhi.modules.security.user.SecurityUser;
 public class AgentController {
     private final AgentService agentService;
     private final AgentTemplateService agentTemplateService;
+    private final DeviceService deviceService;
+    private final AgentChatHistoryService agentChatHistoryService;
+    private final AgentChatAudioService agentChatAudioService;
+    private final RedisUtils redisUtils;
 
     @GetMapping("/list")
     @Operation(summary = "获取用户智能体列表")
     @RequiresPermissions("sys:role:normal")
-    public Result<List<AgentEntity>> getUserAgents() {
+    public Result<List<AgentDTO>> getUserAgents() {
         UserDetail user = SecurityUser.getUser();
-        List<AgentEntity> agents = agentService.getUserAgents(user.getId());
-        return new Result<List<AgentEntity>>().ok(agents);
+        List<AgentDTO> agents = agentService.getUserAgents(user.getId());
+        return new Result<List<AgentDTO>>().ok(agents);
     }
 
     @GetMapping("/all")
@@ -77,9 +94,25 @@ public class AgentController {
     @PostMapping
     @Operation(summary = "创建智能体")
     @RequiresPermissions("sys:role:normal")
-    public Result<Void> save(@RequestBody @Valid AgentCreateDTO dto) {
+    public Result<String> save(@RequestBody @Valid AgentCreateDTO dto) {
         AgentEntity entity = ConvertUtils.sourceToTarget(dto, AgentEntity.class);
 
+        // 获取默认模板
+        AgentTemplateEntity template = agentTemplateService.getDefaultTemplate();
+        if (template != null) {
+            // 设置模板中的默认值
+            entity.setAsrModelId(template.getAsrModelId());
+            entity.setVadModelId(template.getVadModelId());
+            entity.setLlmModelId(template.getLlmModelId());
+            entity.setTtsModelId(template.getTtsModelId());
+            entity.setTtsVoiceId(template.getTtsVoiceId());
+            entity.setMemModelId(template.getMemModelId());
+            entity.setIntentModelId(template.getIntentModelId());
+            entity.setSystemPrompt(template.getSystemPrompt());
+            entity.setLangCode(template.getLangCode());
+            entity.setLanguage(template.getLanguage());
+        }
+
         // 设置用户ID和创建者信息
         UserDetail user = SecurityUser.getUser();
         entity.setUserId(user.getId());
@@ -89,7 +122,7 @@ public class AgentController {
         // ID、智能体编码和排序会在Service层自动生成
         agentService.insert(entity);
 
-        return new Result<>();
+        return new Result<String>().ok(entity.getId());
     }
 
     @PutMapping("/{id}")
@@ -157,6 +190,11 @@ public class AgentController {
     @Operation(summary = "删除智能体")
     @RequiresPermissions("sys:role:normal")
     public Result<Void> delete(@PathVariable String id) {
+        // 先删除关联的设备
+        deviceService.deleteByAgentId(id);
+        // 删除关联的聊天记录
+        agentChatHistoryService.deleteByAgentId(id);
+        // 再删除智能体
         agentService.deleteById(id);
         return new Result<>();
     }
@@ -169,4 +207,72 @@ public class AgentController {
                 .list(new QueryWrapper<AgentTemplateEntity>().orderByAsc("sort"));
         return new Result<List<AgentTemplateEntity>>().ok(list);
     }
+
+    @GetMapping("/{id}/sessions")
+    @Operation(summary = "获取智能体会话列表")
+    @RequiresPermissions("sys:role:normal")
+    @Parameters({
+            @Parameter(name = Constant.PAGE, description = "当前页码，从1开始", required = true),
+            @Parameter(name = Constant.LIMIT, description = "每页显示记录数", required = true),
+    })
+    public Result<PageData<AgentChatSessionDTO>> getAgentSessions(
+            @PathVariable("id") String id,
+            @Parameter(hidden = true) @RequestParam Map<String, Object> params) {
+        params.put("agentId", id);
+        PageData<AgentChatSessionDTO> page = agentChatHistoryService.getSessionListByAgentId(params);
+        return new Result<PageData<AgentChatSessionDTO>>().ok(page);
+    }
+
+    @GetMapping("/{id}/chat-history/{sessionId}")
+    @Operation(summary = "获取智能体聊天记录")
+    @RequiresPermissions("sys:role:normal")
+    public Result<List<AgentChatHistoryDTO>> getAgentChatHistory(
+            @PathVariable("id") String id,
+            @PathVariable("sessionId") String sessionId) {
+        // 获取当前用户
+        UserDetail user = SecurityUser.getUser();
+
+        // 检查权限
+        if (!agentService.checkAgentPermission(id, user.getId())) {
+            return new Result<List<AgentChatHistoryDTO>>().error("没有权限查看该智能体的聊天记录");
+        }
+
+        // 查询聊天记录
+        List<AgentChatHistoryDTO> result = agentChatHistoryService.getChatHistoryBySessionId(id, sessionId);
+        return new Result<List<AgentChatHistoryDTO>>().ok(result);
+    }
+
+    @PostMapping("/audio/{audioId}")
+    @Operation(summary = "获取音频下载ID")
+    @RequiresPermissions("sys:role:normal")
+    public Result<String> getAudioId(@PathVariable("audioId") String audioId) {
+        byte[] audioData = agentChatAudioService.getAudio(audioId);
+        if (audioData == null) {
+            return new Result<String>().error("音频不存在");
+        }
+        String uuid = UUID.randomUUID().toString();
+        redisUtils.set(RedisKeys.getAgentAudioIdKey(uuid), audioId);
+        return new Result<String>().ok(uuid);
+    }
+
+    @GetMapping("/play/{uuid}")
+    @Operation(summary = "播放音频")
+    public ResponseEntity<byte[]> playAudio(@PathVariable("uuid") String uuid) {
+
+        String audioId = (String) redisUtils.get(RedisKeys.getAgentAudioIdKey(uuid));
+        if (StringUtils.isBlank(audioId)) {
+            return ResponseEntity.notFound().build();
+        }
+
+        byte[] audioData = agentChatAudioService.getAudio(audioId);
+        if (audioData == null) {
+            return ResponseEntity.notFound().build();
+        }
+        redisUtils.delete(RedisKeys.getAgentAudioIdKey(uuid));
+        return ResponseEntity.ok()
+                .contentType(MediaType.APPLICATION_OCTET_STREAM)
+                .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"play.wav\"")
+                .body(audioData);
+    }
+
 }

main/manager-api/src/main/java/xiaozhi/modules/agent/dao/AgentDao.java

@@ -1,11 +1,31 @@
 package xiaozhi.modules.agent.dao;
 
 import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
 
+import org.apache.ibatis.annotations.Select;
 import xiaozhi.common.dao.BaseDao;
 import xiaozhi.modules.agent.entity.AgentEntity;
 
 @Mapper
 public interface AgentDao extends BaseDao<AgentEntity> {
+    /**
+     * 获取智能体的设备数量
+     * 
+     * @param agentId 智能体ID
+     * @return 设备数量
+     */
+    Integer getDeviceCountByAgentId(@Param("agentId") String agentId);
 
-}
+    /**
+     * 根据设备MAC地址查询对应设备的默认智能体信息
+     *
+     * @param macAddress 设备MAC地址
+     * @return 默认智能体信息
+     */
+    @Select(" SELECT a.* FROM ai_device d " +
+            " LEFT JOIN ai_agent a ON d.agent_id = a.id " +
+            " WHERE d.mac_address = #{macAddress} " +
+            " ORDER BY d.id DESC LIMIT 1")
+    AgentEntity getDefaultAgentByMacAddress(@Param("macAddress") String macAddress);
+}

main/manager-api/src/main/java/xiaozhi/modules/agent/dao/AiAgentChatAudioDao.java

@@ -0,0 +1,18 @@
+package xiaozhi.modules.agent.dao;
+
+import org.apache.ibatis.annotations.Mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+import xiaozhi.modules.agent.entity.AgentChatAudioEntity;
+
+/**
+ * {@link AgentChatAudioEntity} 智能体聊天音频数据Dao对象
+ *
+ * @author Goody
+ * @version 1.0, 2025/5/8
+ * @since 1.0.0
+ */
+@Mapper
+public interface AiAgentChatAudioDao extends BaseMapper<AgentChatAudioEntity> {
+}

main/manager-api/src/main/java/xiaozhi/modules/agent/dao/AiAgentChatHistoryDao.java

@@ -0,0 +1,31 @@
+package xiaozhi.modules.agent.dao;
+
+import org.apache.ibatis.annotations.Mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+import xiaozhi.modules.agent.entity.AgentChatHistoryEntity;
+
+/**
+ * {@link AgentChatHistoryEntity} 智能体聊天历史记录Dao对象
+ *
+ * @author Goody
+ * @version 1.0, 2025/4/30
+ * @since 1.0.0
+ */
+@Mapper
+public interface AiAgentChatHistoryDao extends BaseMapper<AgentChatHistoryEntity> {
+    /**
+     * 根据智能体ID删除音频
+     *
+     * @param agentId 智能体ID
+     */
+    void deleteAudioByAgentId(String agentId);
+
+    /**
+     * 根据智能体ID删除聊天历史记录
+     *
+     * @param agentId 智能体ID
+     */
+    void deleteHistoryByAgentId(String agentId);
+}

main/manager-api/src/main/java/xiaozhi/modules/agent/dto/AgentChatHistoryDTO.java

@@ -0,0 +1,28 @@
+package xiaozhi.modules.agent.dto;
+
+import java.util.Date;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+/**
+ * 智能体聊天记录DTO
+ */
+@Data
+@Schema(description = "智能体聊天记录")
+public class AgentChatHistoryDTO {
+    @Schema(description = "创建时间")
+    private Date createdAt;
+
+    @Schema(description = "消息类型: 1-用户, 2-智能体")
+    private Byte chatType;
+
+    @Schema(description = "聊天内容")
+    private String content;
+
+    @Schema(description = "音频ID")
+    private String audioId;
+
+    @Schema(description = "MAC地址")
+    private String macAddress;
+}

main/manager-api/src/main/java/xiaozhi/modules/agent/dto/AgentChatHistoryReportDTO.java

@@ -0,0 +1,31 @@
+package xiaozhi.modules.agent.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import lombok.Data;
+
+/**
+ * 小智设备聊天上报请求
+ *
+ * @author Haotian
+ * @version 1.0, 2025/5/8
+ */
+@Data
+@Schema(description = "小智设备聊天上报请求")
+public class AgentChatHistoryReportDTO {
+    @Schema(description = "MAC地址", example = "00:11:22:33:44:55")
+    @NotBlank
+    private String macAddress;
+    @Schema(description = "会话ID", example = "79578c31-f1fb-426a-900e-1e934215f05a")
+    @NotBlank
+    private String sessionId;
+    @Schema(description = "消息类型: 1-用户, 2-智能体", example = "1")
+    @NotNull
+    private Byte chatType;
+    @Schema(description = "聊天内容", example = "你好呀")
+    @NotBlank
+    private String content;
+    @Schema(description = "base64编码的opus音频数据", example = "")
+    private String audioBase64;
+}

main/manager-api/src/main/java/xiaozhi/modules/agent/dto/AgentChatSessionDTO.java

@@ -0,0 +1,26 @@
+package xiaozhi.modules.agent.dto;
+
+import java.time.LocalDateTime;
+
+import lombok.Data;
+
+/**
+ * 智能体会话列表DTO
+ */
+@Data
+public class AgentChatSessionDTO {
+    /**
+     * 会话ID
+     */
+    private String sessionId;
+
+    /**
+     * 会话时间
+     */
+    private LocalDateTime createdAt;
+
+    /**
+     * 聊天条数
+     */
+    private Integer chatCount;
+}

main/manager-api/src/main/java/xiaozhi/modules/agent/dto/AgentDTO.java

@@ -0,0 +1,38 @@
+package xiaozhi.modules.agent.dto;
+
+import java.util.Date;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+/**
+ * 智能体数据传输对象
+ * 用于在服务层和控制器层之间传递智能体相关的数据
+ */
+@Data
+@Schema(description = "智能体对象")
+public class AgentDTO {
+    @Schema(description = "智能体编码", example = "AGT_1234567890")
+    private String id;
+
+    @Schema(description = "智能体名称", example = "客服助手")
+    private String agentName;
+
+    @Schema(description = "语音合成模型名称", example = "tts_model_01")
+    private String ttsModelName;
+
+    @Schema(description = "音色名称", example = "voice_01")
+    private String ttsVoiceName;
+
+    @Schema(description = "大语言模型名称", example = "llm_model_01")
+    private String llmModelName;
+
+    @Schema(description = "角色设定参数", example = "你是一个专业的客服助手，负责回答用户问题并提供帮助")
+    private String systemPrompt;
+
+    @Schema(description = "最后连接时间", example = "2024-03-20 10:00:00")
+    private Date lastConnectedAt;
+
+    @Schema(description = "设备数量", example = "10")
+    private Integer deviceCount;
+}

main/manager-api/src/main/java/xiaozhi/modules/agent/entity/AgentChatAudioEntity.java

@@ -0,0 +1,29 @@
+package xiaozhi.modules.agent.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+
+import lombok.Data;
+
+/**
+ * 智能体聊天音频数据表
+ *
+ * @author Goody
+ * @version 1.0, 2025/5/8
+ * @since 1.0.0
+ */
+@Data
+@TableName("ai_agent_chat_audio")
+public class AgentChatAudioEntity {
+    /**
+     * 主键ID
+     */
+    @TableId(type = IdType.ASSIGN_UUID)
+    private String id;
+
+    /**
+     * 音频opus数据
+     */
+    private byte[] audio;
+}

main/manager-api/src/main/java/xiaozhi/modules/agent/entity/AgentChatHistoryEntity.java

@@ -0,0 +1,81 @@
+package xiaozhi.modules.agent.entity;
+
+import java.util.Date;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/**
+ * 智能体聊天记录表
+ *
+ * @author Goody
+ * @version 1.0, 2025/4/30
+ * @since 1.0.0
+ */
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+@TableName(value = "ai_agent_chat_history")
+public class AgentChatHistoryEntity {
+    /**
+     * 主键ID
+     */
+    @TableId(type = IdType.AUTO)
+    private Long id;
+
+    /**
+     * MAC地址
+     */
+    @TableField(value = "mac_address")
+    private String macAddress;
+
+    /**
+     * 智能体id
+     */
+    @TableField(value = "agent_id")
+    private String agentId;
+
+    /**
+     * 会话ID
+     */
+    @TableField(value = "session_id")
+    private String sessionId;
+
+    /**
+     * 消息类型: 1-用户, 2-智能体
+     */
+    @TableField(value = "chat_type")
+    private Byte chatType;
+
+    /**
+     * 聊天内容
+     */
+    @TableField(value = "content")
+    private String content;
+
+    /**
+     * 音频base64数据
+     */
+    @TableField(value = "audio_id")
+    private String audioId;
+
+    /**
+     * 创建时间
+     */
+    @TableField(value = "created_at")
+    private Date createdAt;
+
+    /**
+     * 更新时间
+     */
+    @TableField(value = "updated_at")
+    private Date updatedAt;
+}

main/manager-api/src/main/java/xiaozhi/modules/agent/service/AgentChatAudioService.java

@@ -0,0 +1,30 @@
+package xiaozhi.modules.agent.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+
+import xiaozhi.modules.agent.entity.AgentChatAudioEntity;
+
+/**
+ * 智能体聊天音频数据表处理service
+ *
+ * @author Goody
+ * @version 1.0, 2025/5/8
+ * @since 1.0.0
+ */
+public interface AgentChatAudioService extends IService<AgentChatAudioEntity> {
+    /**
+     * 保存音频数据
+     *
+     * @param audioData 音频数据
+     * @return 音频ID
+     */
+    String saveAudio(byte[] audioData);
+
+    /**
+     * 获取音频数据
+     *
+     * @param audioId 音频ID
+     * @return 音频数据
+     */
+    byte[] getAudio(String audioId);
+}

main/manager-api/src/main/java/xiaozhi/modules/agent/service/AgentChatHistoryService.java

@@ -0,0 +1,45 @@
+package xiaozhi.modules.agent.service;
+
+import java.util.List;
+import java.util.Map;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+
+import xiaozhi.common.page.PageData;
+import xiaozhi.modules.agent.dto.AgentChatHistoryDTO;
+import xiaozhi.modules.agent.dto.AgentChatSessionDTO;
+import xiaozhi.modules.agent.entity.AgentChatHistoryEntity;
+
+/**
+ * 智能体聊天记录表处理service
+ *
+ * @author Goody
+ * @version 1.0, 2025/4/30
+ * @since 1.0.0
+ */
+public interface AgentChatHistoryService extends IService<AgentChatHistoryEntity> {
+
+    /**
+     * 根据智能体ID获取会话列表
+     *
+     * @param params 查询参数，包含agentId、page、limit
+     * @return 分页的会话列表
+     */
+    PageData<AgentChatSessionDTO> getSessionListByAgentId(Map<String, Object> params);
+
+    /**
+     * 根据会话ID获取聊天记录列表
+     *
+     * @param agentId   智能体ID
+     * @param sessionId 会话ID
+     * @return 聊天记录列表
+     */
+    List<AgentChatHistoryDTO> getChatHistoryBySessionId(String agentId, String sessionId);
+
+    /**
+     * 根据智能体ID删除聊天记录
+     *
+     * @param agentId 智能体ID
+     */
+    void deleteByAgentId(String agentId);
+}

main/manager-api/src/main/java/xiaozhi/modules/agent/service/AgentService.java

@@ -5,21 +5,78 @@ import java.util.Map;
 
 import xiaozhi.common.page.PageData;
 import xiaozhi.common.service.BaseService;
+import xiaozhi.modules.agent.dto.AgentDTO;
 import xiaozhi.modules.agent.entity.AgentEntity;
 
+/**
+ * 智能体表处理service
+ *
+ * @author Goody
+ * @version 1.0, 2025/4/30
+ * @since 1.0.0
+ */
 public interface AgentService extends BaseService<AgentEntity> {
     /**
-     * 根据用户ID获取智能体列表
-     */
-    List<AgentEntity> getUserAgents(Long userId);
-
-    /**
-     * 管理员获取所有智能体列表（分页）
+     * 获取管理员智能体列表
+     *
+     * @param params 查询参数
+     * @return 分页数据
      */
     PageData<AgentEntity> adminAgentList(Map<String, Object> params);
 
     /**
-     * 获取智能体详情
+     * 根据ID获取智能体
+     *
+     * @param id 智能体ID
+     * @return 智能体实体
      */
     AgentEntity getAgentById(String id);
-}
+
+    /**
+     * 插入智能体
+     *
+     * @param entity 智能体实体
+     * @return 是否成功
+     */
+    boolean insert(AgentEntity entity);
+
+    /**
+     * 根据用户ID删除智能体
+     *
+     * @param userId 用户ID
+     */
+    void deleteAgentByUserId(Long userId);
+
+    /**
+     * 获取用户智能体列表
+     *
+     * @param userId 用户ID
+     * @return 智能体列表
+     */
+    List<AgentDTO> getUserAgents(Long userId);
+
+    /**
+     * 根据智能体ID获取设备数量
+     *
+     * @param agentId 智能体ID
+     * @return 设备数量
+     */
+    Integer getDeviceCountByAgentId(String agentId);
+
+    /**
+     * 根据设备MAC地址查询对应设备的默认智能体信息
+     *
+     * @param macAddress 设备MAC地址
+     * @return 默认智能体信息，不存在时返回null
+     */
+    AgentEntity getDefaultAgentByMacAddress(String macAddress);
+
+    /**
+     * 检查用户是否有权限访问智能体
+     *
+     * @param agentId 智能体ID
+     * @param userId  用户ID
+     * @return 是否有权限
+     */
+    boolean checkAgentPermission(String agentId, Long userId);
+}

main/manager-api/src/main/java/xiaozhi/modules/agent/service/AgentTemplateService.java

@@ -11,4 +11,18 @@ import xiaozhi.modules.agent.entity.AgentTemplateEntity;
  */
 public interface AgentTemplateService extends IService<AgentTemplateEntity> {
 
+    /**
+     * 获取默认模板
+     * 
+     * @return 默认模板实体
+     */
+    AgentTemplateEntity getDefaultTemplate();
+
+    /**
+     * 更新默认模板中的模型ID
+     * 
+     * @param modelType 模型类型
+     * @param modelId   模型ID
+     */
+    void updateDefaultTemplateModelId(String modelType, String modelId);
 }

main/manager-api/src/main/java/xiaozhi/modules/agent/service/biz/AgentChatHistoryBizService.java

@@ -0,0 +1,22 @@
+package xiaozhi.modules.agent.service.biz;
+
+import xiaozhi.modules.agent.dto.AgentChatHistoryReportDTO;
+
+/**
+ * 智能体聊天历史业务逻辑层
+ *
+ * @author Goody
+ * @version 1.0, 2025/4/30
+ * @since 1.0.0
+ */
+public interface AgentChatHistoryBizService {
+
+    /**
+     * 聊天上报方法
+     *
+     * @param agentChatHistoryReportDTO 包含聊天上报所需信息的输入对象
+     *                                  例如：设备MAC地址、文件类型、内容等
+     * @return 上传结果，true表示成功，false表示失败
+     */
+    Boolean report(AgentChatHistoryReportDTO agentChatHistoryReportDTO);
+}

main/manager-api/src/main/java/xiaozhi/modules/agent/service/biz/impl/AgentChatHistoryBizServiceImpl.java

@@ -0,0 +1,88 @@
+package xiaozhi.modules.agent.service.biz.impl;
+
+import java.util.Base64;
+import java.util.Date;
+
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import xiaozhi.common.redis.RedisKeys;
+import xiaozhi.common.redis.RedisUtils;
+import xiaozhi.modules.agent.dto.AgentChatHistoryReportDTO;
+import xiaozhi.modules.agent.entity.AgentChatHistoryEntity;
+import xiaozhi.modules.agent.entity.AgentEntity;
+import xiaozhi.modules.agent.service.AgentChatAudioService;
+import xiaozhi.modules.agent.service.AgentChatHistoryService;
+import xiaozhi.modules.agent.service.AgentService;
+import xiaozhi.modules.agent.service.biz.AgentChatHistoryBizService;
+
+/**
+ * {@link AgentChatHistoryBizService} impl
+ *
+ * @author Goody
+ * @version 1.0, 2025/4/30
+ * @since 1.0.0
+ */
+@Service
+@Slf4j
+@RequiredArgsConstructor
+public class AgentChatHistoryBizServiceImpl implements AgentChatHistoryBizService {
+    private final AgentService agentService;
+    private final AgentChatHistoryService agentChatHistoryService;
+    private final AgentChatAudioService agentChatAudioService;
+    private final RedisUtils redisUtils;
+
+    /**
+     * 处理聊天记录上报，包括文件上传和相关信息记录
+     *
+     * @param report 包含聊天上报所需信息的输入对象
+     * @return 上传结果，true表示成功，false表示失败
+     */
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public Boolean report(AgentChatHistoryReportDTO report) {
+        String macAddress = report.getMacAddress();
+        Byte chatType = report.getChatType();
+        log.info("小智设备聊天上报请求: macAddress={}, type={}", macAddress, chatType);
+
+        // 1. base64解码report.getOpusDataBase64(),存入ai_agent_chat_audio表
+        String audioId = null;
+        if (report.getAudioBase64() != null && !report.getAudioBase64().isEmpty()) {
+            try {
+                byte[] audioData = Base64.getDecoder().decode(report.getAudioBase64());
+                audioId = agentChatAudioService.saveAudio(audioData);
+                log.info("音频数据保存成功，audioId={}", audioId);
+            } catch (Exception e) {
+                log.error("音频数据保存失败", e);
+                return false;
+            }
+        }
+
+        // 2. 组装上报数据
+        // 2.1 根据设备MAC地址查询对应的默认智能体，判断是否需要上报
+        AgentEntity agentEntity = agentService.getDefaultAgentByMacAddress(macAddress);
+        if (agentEntity == null) {
+            return false;
+        }
+        String agentId = agentEntity.getId();
+        log.info("设备 {} 对应智能体 {} 上报", macAddress, agentEntity.getId());
+
+        // 2.2 构建聊天记录实体
+        AgentChatHistoryEntity entity = AgentChatHistoryEntity.builder()
+                .macAddress(macAddress)
+                .agentId(agentId)
+                .sessionId(report.getSessionId())
+                .chatType(report.getChatType())
+                .content(report.getContent())
+                .audioId(audioId)
+                .build();
+
+        // 3. 保存数据
+        agentChatHistoryService.save(entity);
+        // 4. 更新设备最后对话时间
+        redisUtils.set(RedisKeys.getAgentDeviceLastConnectedAtById(agentId), new Date());
+        return Boolean.TRUE;
+    }
+}

main/manager-api/src/main/java/xiaozhi/modules/agent/service/impl/AgentChatAudioServiceImpl.java

@@ -0,0 +1,34 @@
+package xiaozhi.modules.agent.service.impl;
+
+import org.springframework.stereotype.Service;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+
+import xiaozhi.modules.agent.dao.AiAgentChatAudioDao;
+import xiaozhi.modules.agent.entity.AgentChatAudioEntity;
+import xiaozhi.modules.agent.service.AgentChatAudioService;
+
+/**
+ * 智能体聊天音频数据表处理service {@link AgentChatAudioService} impl
+ *
+ * @author Goody
+ * @version 1.0, 2025/5/8
+ * @since 1.0.0
+ */
+@Service
+public class AgentChatAudioServiceImpl extends ServiceImpl<AiAgentChatAudioDao, AgentChatAudioEntity>
+        implements AgentChatAudioService {
+    @Override
+    public String saveAudio(byte[] audioData) {
+        AgentChatAudioEntity entity = new AgentChatAudioEntity();
+        entity.setAudio(audioData);
+        save(entity);
+        return entity.getId();
+    }
+
+    @Override
+    public byte[] getAudio(String audioId) {
+        AgentChatAudioEntity entity = getById(audioId);
+        return entity != null ? entity.getAudio() : null;
+    }
+}

main/manager-api/src/main/java/xiaozhi/modules/agent/service/impl/AgentChatHistoryServiceImpl.java

@@ -0,0 +1,85 @@
+package xiaozhi.modules.agent.service.impl;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+
+import xiaozhi.common.constant.Constant;
+import xiaozhi.common.page.PageData;
+import xiaozhi.common.utils.ConvertUtils;
+import xiaozhi.modules.agent.dao.AiAgentChatHistoryDao;
+import xiaozhi.modules.agent.dto.AgentChatHistoryDTO;
+import xiaozhi.modules.agent.dto.AgentChatSessionDTO;
+import xiaozhi.modules.agent.entity.AgentChatHistoryEntity;
+import xiaozhi.modules.agent.service.AgentChatHistoryService;
+
+/**
+ * 智能体聊天记录表处理service {@link AgentChatHistoryService} impl
+ *
+ * @author Goody
+ * @version 1.0, 2025/4/30
+ * @since 1.0.0
+ */
+@Service
+public class AgentChatHistoryServiceImpl extends ServiceImpl<AiAgentChatHistoryDao, AgentChatHistoryEntity>
+        implements AgentChatHistoryService {
+
+    @Override
+    public PageData<AgentChatSessionDTO> getSessionListByAgentId(Map<String, Object> params) {
+        String agentId = (String) params.get("agentId");
+        int page = Integer.parseInt(params.get(Constant.PAGE).toString());
+        int limit = Integer.parseInt(params.get(Constant.LIMIT).toString());
+
+        // 构建查询条件
+        QueryWrapper<AgentChatHistoryEntity> wrapper = new QueryWrapper<>();
+        wrapper.select("session_id", "MAX(created_at) as created_at", "COUNT(*) as chat_count")
+                .eq("agent_id", agentId)
+                .groupBy("session_id")
+                .orderByDesc("created_at");
+
+        // 执行分页查询
+        Page<Map<String, Object>> pageParam = new Page<>(page, limit);
+        IPage<Map<String, Object>> result = this.baseMapper.selectMapsPage(pageParam, wrapper);
+
+        List<AgentChatSessionDTO> records = result.getRecords().stream().map(map -> {
+            AgentChatSessionDTO dto = new AgentChatSessionDTO();
+            dto.setSessionId((String) map.get("session_id"));
+            dto.setCreatedAt((LocalDateTime) map.get("created_at"));
+            dto.setChatCount(((Number) map.get("chat_count")).intValue());
+            return dto;
+        }).collect(Collectors.toList());
+
+        return new PageData<>(records, result.getTotal());
+    }
+
+    @Override
+    public List<AgentChatHistoryDTO> getChatHistoryBySessionId(String agentId, String sessionId) {
+        // 构建查询条件
+        QueryWrapper<AgentChatHistoryEntity> wrapper = new QueryWrapper<>();
+        wrapper.eq("agent_id", agentId)
+                .eq("session_id", sessionId)
+                .orderByAsc("created_at");
+
+        // 查询聊天记录
+        List<AgentChatHistoryEntity> historyList = list(wrapper);
+
+        // 转换为DTO
+        return ConvertUtils.sourceToTarget(historyList, AgentChatHistoryDTO.class);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void deleteByAgentId(String agentId) {
+        baseMapper.deleteAudioByAgentId(agentId);
+        baseMapper.deleteHistoryByAgentId(agentId);
+    }
+}

main/manager-api/src/main/java/xiaozhi/modules/agent/service/impl/AgentServiceImpl.java

@@ -3,37 +3,43 @@ package xiaozhi.modules.agent.service.impl;
 import java.util.List;
 import java.util.Map;
 import java.util.UUID;
+import java.util.stream.Collectors;
 
+import org.apache.commons.lang3.StringUtils;
 import org.springframework.stereotype.Service;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 
+import lombok.AllArgsConstructor;
 import xiaozhi.common.page.PageData;
+import xiaozhi.common.redis.RedisKeys;
+import xiaozhi.common.redis.RedisUtils;
 import xiaozhi.common.service.impl.BaseServiceImpl;
 import xiaozhi.modules.agent.dao.AgentDao;
+import xiaozhi.modules.agent.dto.AgentDTO;
 import xiaozhi.modules.agent.entity.AgentEntity;
 import xiaozhi.modules.agent.service.AgentService;
+import xiaozhi.modules.device.service.DeviceService;
+import xiaozhi.modules.model.service.ModelConfigService;
+import xiaozhi.modules.security.user.SecurityUser;
+import xiaozhi.modules.sys.enums.SuperAdminEnum;
+import xiaozhi.modules.timbre.service.TimbreService;
 
 @Service
+@AllArgsConstructor
 public class AgentServiceImpl extends BaseServiceImpl<AgentDao, AgentEntity> implements AgentService {
     private final AgentDao agentDao;
-
-    public AgentServiceImpl(AgentDao agentDao) {
-        this.agentDao = agentDao;
-    }
-
-    @Override
-    public List<AgentEntity> getUserAgents(Long userId) {
-        QueryWrapper<AgentEntity> wrapper = new QueryWrapper<>();
-        wrapper.eq("user_id", userId);
-        return agentDao.selectList(wrapper);
-    }
+    private final TimbreService timbreModelService;
+    private final ModelConfigService modelConfigService;
+    private final RedisUtils redisUtils;
+    private final DeviceService deviceService;
 
     @Override
     public PageData<AgentEntity> adminAgentList(Map<String, Object> params) {
         IPage<AgentEntity> page = agentDao.selectPage(
-                getPage(params, "sort", true),
+                getPage(params, "agent_name", true),
                 new QueryWrapper<>());
         return new PageData<>(page.getRecords(), page.getTotal());
     }
@@ -62,4 +68,88 @@ public class AgentServiceImpl extends BaseServiceImpl<AgentDao, AgentEntity> imp
 
         return super.insert(entity);
     }
-}
+
+    @Override
+    public void deleteAgentByUserId(Long userId) {
+        UpdateWrapper<AgentEntity> wrapper = new UpdateWrapper<>();
+        wrapper.eq("user_id", userId);
+        baseDao.delete(wrapper);
+    }
+
+    @Override
+    public List<AgentDTO> getUserAgents(Long userId) {
+        QueryWrapper<AgentEntity> wrapper = new QueryWrapper<>();
+        wrapper.eq("user_id", userId);
+        List<AgentEntity> agents = agentDao.selectList(wrapper);
+        return agents.stream().map(agent -> {
+            AgentDTO dto = new AgentDTO();
+            dto.setId(agent.getId());
+            dto.setAgentName(agent.getAgentName());
+            dto.setSystemPrompt(agent.getSystemPrompt());
+
+            // 获取 TTS 模型名称
+            dto.setTtsModelName(modelConfigService.getModelNameById(agent.getTtsModelId()));
+
+            // 获取 LLM 模型名称
+            dto.setLlmModelName(modelConfigService.getModelNameById(agent.getLlmModelId()));
+
+            // 获取 TTS 音色名称
+            dto.setTtsVoiceName(timbreModelService.getTimbreNameById(agent.getTtsVoiceId()));
+
+            // 获取智能体最近的最后连接时长
+            dto.setLastConnectedAt(deviceService.getLatestLastConnectionTime(agent.getId()));
+
+            // 获取设备数量
+            dto.setDeviceCount(getDeviceCountByAgentId(agent.getId()));
+            return dto;
+        }).collect(Collectors.toList());
+    }
+
+    @Override
+    public Integer getDeviceCountByAgentId(String agentId) {
+        if (StringUtils.isBlank(agentId)) {
+            return 0;
+        }
+
+        // 先从Redis中获取
+        Integer cachedCount = (Integer) redisUtils.get(RedisKeys.getAgentDeviceCountById(agentId));
+        if (cachedCount != null) {
+            return cachedCount;
+        }
+
+        // 如果Redis中没有，则从数据库查询
+        Integer deviceCount = agentDao.getDeviceCountByAgentId(agentId);
+
+        // 将结果存入Redis
+        if (deviceCount != null) {
+            redisUtils.set(RedisKeys.getAgentDeviceCountById(agentId), deviceCount, 60);
+        }
+
+        return deviceCount != null ? deviceCount : 0;
+    }
+
+    @Override
+    public AgentEntity getDefaultAgentByMacAddress(String macAddress) {
+        if (StringUtils.isEmpty(macAddress)) {
+            return null;
+        }
+        return agentDao.getDefaultAgentByMacAddress(macAddress);
+    }
+
+    @Override
+    public boolean checkAgentPermission(String agentId, Long userId) {
+        // 获取智能体信息
+        AgentEntity agent = getAgentById(agentId);
+        if (agent == null) {
+            return false;
+        }
+
+        // 如果是超级管理员，直接返回true
+        if (SecurityUser.getUser().getSuperAdmin() == SuperAdminEnum.YES.value()) {
+            return true;
+        }
+
+        // 检查是否是智能体的所有者
+        return userId.equals(agent.getUserId());
+    }
+}

main/manager-api/src/main/java/xiaozhi/modules/agent/service/impl/AgentTemplateServiceImpl.java

@@ -2,6 +2,8 @@ package xiaozhi.modules.agent.service.impl;
 
 import org.springframework.stereotype.Service;
 
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 
 import xiaozhi.modules.agent.dao.AgentTemplateDao;
@@ -15,6 +17,53 @@ import xiaozhi.modules.agent.service.AgentTemplateService;
  */
 @Service
 public class AgentTemplateServiceImpl extends ServiceImpl<AgentTemplateDao, AgentTemplateEntity>
-                implements AgentTemplateService {
+        implements AgentTemplateService {
 
+    /**
+     * 获取默认模板
+     * 
+     * @return 默认模板实体
+     */
+    public AgentTemplateEntity getDefaultTemplate() {
+        LambdaQueryWrapper<AgentTemplateEntity> wrapper = new LambdaQueryWrapper<>();
+        wrapper.orderByAsc(AgentTemplateEntity::getSort)
+                .last("LIMIT 1");
+        return this.getOne(wrapper);
+    }
+
+    /**
+     * 更新默认模板中的模型ID
+     * 
+     * @param modelType 模型类型
+     * @param modelId   模型ID
+     */
+    @Override
+    public void updateDefaultTemplateModelId(String modelType, String modelId) {
+        modelType = modelType.toUpperCase();
+
+        UpdateWrapper<AgentTemplateEntity> wrapper = new UpdateWrapper<>();
+        switch (modelType) {
+            case "ASR":
+                wrapper.set("asr_model_id", modelId);
+                break;
+            case "VAD":
+                wrapper.set("vad_model_id", modelId);
+                break;
+            case "LLM":
+                wrapper.set("llm_model_id", modelId);
+                break;
+            case "TTS":
+                wrapper.set("tts_model_id", modelId);
+                wrapper.set("tts_voice_id", null);
+                break;
+            case "MEMORY":
+                wrapper.set("mem_model_id", modelId);
+                break;
+            case "INTENT":
+                wrapper.set("intent_model_id", modelId);
+                break;
+        }
+        wrapper.ge("sort", 0);
+        update(wrapper);
+    }
 }

main/manager-api/src/main/java/xiaozhi/modules/config/controller/ConfigController.java

@@ -0,0 +1,44 @@
+package xiaozhi.modules.config.controller;
+
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
+import lombok.AllArgsConstructor;
+import xiaozhi.common.utils.Result;
+import xiaozhi.common.validator.ValidatorUtils;
+import xiaozhi.modules.config.dto.AgentModelsDTO;
+import xiaozhi.modules.config.service.ConfigService;
+
+/**
+ * xiaozhi-server 配置获取
+ *
+ * @since 1.0.0
+ */
+@RestController
+@RequestMapping("config")
+@Tag(name = "参数管理")
+@AllArgsConstructor
+public class ConfigController {
+    private final ConfigService configService;
+
+    @PostMapping("server-base")
+    @Operation(summary = "获取配置")
+    public Result<Object> getConfig() {
+        Object config = configService.getConfig(true);
+        return new Result<Object>().ok(config);
+    }
+
+    @PostMapping("agent-models")
+    @Operation(summary = "获取智能体模型")
+    public Result<Object> getAgentModels(@Valid @RequestBody AgentModelsDTO dto) {
+        // 效验数据
+        ValidatorUtils.validateEntity(dto);
+        Object models = configService.getAgentModels(dto.getMacAddress(), dto.getSelectedModule());
+        return new Result<Object>().ok(models);
+    }
+}

main/manager-api/src/main/java/xiaozhi/modules/config/dto/AgentModelsDTO.java

@@ -0,0 +1,25 @@
+package xiaozhi.modules.config.dto;
+
+import java.util.Map;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import lombok.Data;
+
+@Data
+@Schema(description = "获取智能体模型配置DTO")
+public class AgentModelsDTO {
+
+    @NotBlank(message = "设备MAC地址不能为空")
+    @Schema(description = "设备MAC地址")
+    private String macAddress;
+
+    @NotBlank(message = "客户端ID不能为空")
+    @Schema(description = "客户端ID")
+    private String clientId;
+
+    @NotNull(message = "客户端已实例化的模型不能为空")
+    @Schema(description = "客户端已实例化的模型")
+    private Map<String, String> selectedModule;
+}

main/manager-api/src/main/java/xiaozhi/modules/config/init/SystemInitConfig.java

@@ -0,0 +1,41 @@
+package xiaozhi.modules.config.init;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.DependsOn;
+
+import jakarta.annotation.PostConstruct;
+import xiaozhi.common.constant.Constant;
+import xiaozhi.common.redis.RedisKeys;
+import xiaozhi.common.redis.RedisUtils;
+import xiaozhi.modules.config.service.ConfigService;
+import xiaozhi.modules.sys.service.SysParamsService;
+
+@Configuration
+@DependsOn("liquibase")
+public class SystemInitConfig {
+
+    @Autowired
+    private SysParamsService sysParamsService;
+
+    @Autowired
+    private ConfigService configService;
+
+    @Autowired
+    private RedisUtils redisUtils;
+
+    @PostConstruct
+    public void init() {
+        // 检查版本号
+        String redisVersion = (String) redisUtils.get(RedisKeys.getVersionKey());
+        if (!Constant.VERSION.equals(redisVersion)) {
+            // 如果版本不一致，清空Redis
+            redisUtils.emptyAll();
+            // 存储新版本号
+            redisUtils.set(RedisKeys.getVersionKey(), Constant.VERSION);
+        }
+
+        sysParamsService.initServerSecret();
+        configService.getConfig(false);
+    }
+}

main/manager-api/src/main/java/xiaozhi/modules/config/service/ConfigService.java

@@ -0,0 +1,22 @@
+package xiaozhi.modules.config.service;
+
+import java.util.Map;
+
+public interface ConfigService {
+    /**
+     * 获取服务器配置
+     * 
+     * @param isCache 是否缓存
+     * @return 配置信息
+     */
+    Object getConfig(Boolean isCache);
+
+    /**
+     * 获取智能体模型配置
+     * 
+     * @param macAddress     MAC地址
+     * @param selectedModule 客户端已实例化的模型
+     * @return 模型配置信息
+     */
+    Map<String, Object> getAgentModels(String macAddress, Map<String, String> selectedModule);
+}

main/manager-api/src/main/java/xiaozhi/modules/config/service/impl/ConfigServiceImpl.java

@@ -0,0 +1,286 @@
+package xiaozhi.modules.config.service.impl;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+
+import lombok.AllArgsConstructor;
+import xiaozhi.common.exception.ErrorCode;
+import xiaozhi.common.exception.RenException;
+import xiaozhi.common.redis.RedisKeys;
+import xiaozhi.common.redis.RedisUtils;
+import xiaozhi.common.utils.JsonUtils;
+import xiaozhi.modules.agent.entity.AgentEntity;
+import xiaozhi.modules.agent.entity.AgentTemplateEntity;
+import xiaozhi.modules.agent.service.AgentService;
+import xiaozhi.modules.agent.service.AgentTemplateService;
+import xiaozhi.modules.config.service.ConfigService;
+import xiaozhi.modules.device.entity.DeviceEntity;
+import xiaozhi.modules.device.service.DeviceService;
+import xiaozhi.modules.model.entity.ModelConfigEntity;
+import xiaozhi.modules.model.service.ModelConfigService;
+import xiaozhi.modules.sys.dto.SysParamsDTO;
+import xiaozhi.modules.sys.service.SysParamsService;
+import xiaozhi.modules.timbre.service.TimbreService;
+import xiaozhi.modules.timbre.vo.TimbreDetailsVO;
+
+@Service
+@AllArgsConstructor
+public class ConfigServiceImpl implements ConfigService {
+    private final SysParamsService sysParamsService;
+    private final DeviceService deviceService;
+    private final ModelConfigService modelConfigService;
+    private final AgentService agentService;
+    private final AgentTemplateService agentTemplateService;
+    private final RedisUtils redisUtils;
+    private final TimbreService timbreService;
+
+    @Override
+    public Object getConfig(Boolean isCache) {
+        if (isCache) {
+            // 先从Redis获取配置
+            Object cachedConfig = redisUtils.get(RedisKeys.getServerConfigKey());
+            if (cachedConfig != null) {
+                return cachedConfig;
+            }
+        }
+
+        // 构建配置信息
+        Map<String, Object> result = new HashMap<>();
+        buildConfig(result);
+
+        // 查询默认智能体
+        AgentTemplateEntity agent = agentTemplateService.getDefaultTemplate();
+        if (agent == null) {
+            throw new RenException("默认智能体未找到");
+        }
+
+        // 构建模块配置
+        buildModuleConfig(
+                null,
+                null,
+                null,
+                agent.getVadModelId(),
+                agent.getAsrModelId(),
+                null,
+                null,
+                null,
+                null,
+                result,
+                isCache);
+
+        // 将配置存入Redis
+        redisUtils.set(RedisKeys.getServerConfigKey(), result);
+
+        return result;
+    }
+
+    @Override
+    public Map<String, Object> getAgentModels(String macAddress, Map<String, String> selectedModule) {
+        // 根据MAC地址查找设备
+        DeviceEntity device = deviceService.getDeviceByMacAddress(macAddress);
+        if (device == null) {
+            // 如果设备，去redis里看看有没有需要连接的设备
+            String cachedCode = deviceService.geCodeByDeviceId(macAddress);
+            if (StringUtils.isNotBlank(cachedCode)) {
+                throw new RenException(ErrorCode.OTA_DEVICE_NEED_BIND, cachedCode);
+            }
+            throw new RenException(ErrorCode.OTA_DEVICE_NOT_FOUND, "not found device");
+        }
+
+        // 获取智能体信息
+        AgentEntity agent = agentService.getAgentById(device.getAgentId());
+        if (agent == null) {
+            throw new RenException("智能体未找到");
+        }
+        // 获取音色信息
+        String voice = null;
+        TimbreDetailsVO timbre = timbreService.get(agent.getTtsVoiceId());
+        if (timbre != null) {
+            voice = timbre.getTtsVoice();
+        }
+        // 构建返回数据
+        Map<String, Object> result = new HashMap<>();
+        // 获取单台设备每天最多输出字数
+        String deviceMaxOutputSize = sysParamsService.getValue("device_max_output_size", true);
+        result.put("device_max_output_size", deviceMaxOutputSize);
+        // 如果客户端已实例化模型，则不返回
+        String alreadySelectedVadModelId = (String) selectedModule.get("VAD");
+        if (alreadySelectedVadModelId != null && alreadySelectedVadModelId.equals(agent.getVadModelId())) {
+            agent.setVadModelId(null);
+        }
+        String alreadySelectedAsrModelId = (String) selectedModule.get("ASR");
+        if (alreadySelectedAsrModelId != null && alreadySelectedAsrModelId.equals(agent.getAsrModelId())) {
+            agent.setAsrModelId(null);
+        }
+
+        // 构建模块配置
+        buildModuleConfig(
+                agent.getAgentName(),
+                agent.getSystemPrompt(),
+                voice,
+                agent.getVadModelId(),
+                agent.getAsrModelId(),
+                agent.getLlmModelId(),
+                agent.getTtsModelId(),
+                agent.getMemModelId(),
+                agent.getIntentModelId(),
+                result,
+                true);
+
+        return result;
+    }
+
+    /**
+     * 构建配置信息
+     * 
+     * @param paramsList 系统参数列表
+     * @return 配置信息
+     */
+    private Object buildConfig(Map<String, Object> config) {
+
+        // 查询所有系统参数
+        List<SysParamsDTO> paramsList = sysParamsService.list(new HashMap<>());
+
+        for (SysParamsDTO param : paramsList) {
+            String[] keys = param.getParamCode().split("\\.");
+            Map<String, Object> current = config;
+
+            // 遍历除最后一个key之外的所有key
+            for (int i = 0; i < keys.length - 1; i++) {
+                String key = keys[i];
+                if (!current.containsKey(key)) {
+                    current.put(key, new HashMap<String, Object>());
+                }
+                current = (Map<String, Object>) current.get(key);
+            }
+
+            // 处理最后一个key
+            String lastKey = keys[keys.length - 1];
+            String value = param.getParamValue();
+
+            // 根据valueType转换值
+            switch (param.getValueType().toLowerCase()) {
+                case "number":
+                    try {
+                        double doubleValue = Double.parseDouble(value);
+                        // 如果数值是整数形式，则转换为Integer
+                        if (doubleValue == (int) doubleValue) {
+                            current.put(lastKey, (int) doubleValue);
+                        } else {
+                            current.put(lastKey, doubleValue);
+                        }
+                    } catch (NumberFormatException e) {
+                        current.put(lastKey, value);
+                    }
+                    break;
+                case "boolean":
+                    current.put(lastKey, Boolean.parseBoolean(value));
+                    break;
+                case "array":
+                    // 将分号分隔的字符串转换为数字数组
+                    List<String> list = new ArrayList<>();
+                    for (String num : value.split(";")) {
+                        if (StringUtils.isNotBlank(num)) {
+                            list.add(num.trim());
+                        }
+                    }
+                    current.put(lastKey, list);
+                    break;
+                case "json":
+                    try {
+                        current.put(lastKey, JsonUtils.parseObject(value, Object.class));
+                    } catch (Exception e) {
+                        current.put(lastKey, value);
+                    }
+                    break;
+                default:
+                    current.put(lastKey, value);
+            }
+        }
+
+        return config;
+    }
+
+    /**
+     * 构建模块配置
+     * 
+     * @param prompt        提示词
+     * @param voice         音色
+     * @param vadModelId    VAD模型ID
+     * @param asrModelId    ASR模型ID
+     * @param llmModelId    LLM模型ID
+     * @param ttsModelId    TTS模型ID
+     * @param memModelId    记忆模型ID
+     * @param intentModelId 意图模型ID
+     * @param result        结果Map
+     */
+    private void buildModuleConfig(
+            String assistantName,
+            String prompt,
+            String voice,
+            String vadModelId,
+            String asrModelId,
+            String llmModelId,
+            String ttsModelId,
+            String memModelId,
+            String intentModelId,
+            Map<String, Object> result,
+            boolean isCache) {
+        Map<String, String> selectedModule = new HashMap<>();
+
+        String[] modelTypes = { "VAD", "ASR", "TTS", "Memory", "Intent", "LLM" };
+        String[] modelIds = { vadModelId, asrModelId, ttsModelId, memModelId, intentModelId, llmModelId };
+        String intentLLMModelId = null;
+
+        for (int i = 0; i < modelIds.length; i++) {
+            if (modelIds[i] == null) {
+                continue;
+            }
+            ModelConfigEntity model = modelConfigService.getModelById(modelIds[i], isCache);
+            Map<String, Object> typeConfig = new HashMap<>();
+            if (model.getConfigJson() != null) {
+                typeConfig.put(model.getId(), model.getConfigJson());
+                // 如果是TTS类型，添加private_voice属性
+                if ("TTS".equals(modelTypes[i]) && voice != null) {
+                    ((Map<String, Object>) model.getConfigJson()).put("private_voice", voice);
+                }
+                // 如果是Intent类型，且type=intent_llm，则给他添加附加模型
+                if ("Intent".equals(modelTypes[i])) {
+                    Map<String, Object> map = (Map<String, Object>) model.getConfigJson();
+                    if ("intent_llm".equals(map.get("type"))) {
+                        intentLLMModelId = (String) map.get("llm");
+                        if (intentLLMModelId != null && intentLLMModelId.equals(llmModelId)) {
+                            intentLLMModelId = null;
+                        }
+                    }
+                    if (map.get("functions") != null) {
+                        String functionStr = (String) map.get("functions");
+                        if (StringUtils.isNotBlank(functionStr)) {
+                            String[] functions = functionStr.split("\\;");
+                            map.put("functions", functions);
+                        }
+                    }
+                }
+                // 如果是LLM类型，且intentLLMModelId不为空，则添加附加模型
+                if ("LLM".equals(modelTypes[i]) && intentLLMModelId != null) {
+                    ModelConfigEntity intentLLM = modelConfigService.getModelById(intentLLMModelId, isCache);
+                    typeConfig.put(intentLLM.getId(), intentLLM.getConfigJson());
+                }
+            }
+            result.put(modelTypes[i], typeConfig);
+
+            selectedModule.put(modelTypes[i], model.getId());
+        }
+
+        result.put("selected_module", selectedModule);
+        if (StringUtils.isNotBlank(prompt)) {
+            prompt = prompt.replace("{{assistant_name}}", StringUtils.isBlank(assistantName) ? "小智" : assistantName);
+        }
+        result.put("prompt", prompt);
+    }
+}

main/manager-api/src/main/java/xiaozhi/modules/device/controller/DeviceController.java

@@ -7,6 +7,7 @@ import org.apache.shiro.authz.annotation.RequiresPermissions;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
@@ -19,7 +20,7 @@ import xiaozhi.common.redis.RedisKeys;
 import xiaozhi.common.redis.RedisUtils;
 import xiaozhi.common.user.UserDetail;
 import xiaozhi.common.utils.Result;
-import xiaozhi.modules.device.dto.DeviceBindDTO;
+import xiaozhi.modules.device.dto.DeviceRegisterDTO;
 import xiaozhi.modules.device.dto.DeviceUnBindDTO;
 import xiaozhi.modules.device.entity.DeviceEntity;
 import xiaozhi.modules.device.service.DeviceService;
@@ -38,16 +39,29 @@ public class DeviceController {
     @Operation(summary = "绑定设备")
     @RequiresPermissions("sys:role:normal")
     public Result<Void> bindDevice(@PathVariable String agentId, @PathVariable String deviceCode) {
-        String macAddress = (String) redisUtils.get(RedisKeys.getDeviceCaptchaKey(deviceCode));
-        if (StringUtils.isBlank(macAddress)) {
-            return new Result<Void>().error(ErrorCode.DEVICE_CAPTCHA_ERROR);
-        }
-        Long user = SecurityUser.getUser().getId();
-        DeviceBindDTO deviceBindDTO = new DeviceBindDTO(macAddress, user, agentId);
-        deviceService.bindDevice(deviceBindDTO);
+        deviceService.deviceActivation(agentId, deviceCode);
         return new Result<>();
     }
 
+    @PostMapping("/register")
+    @Operation(summary = "注册设备")
+    public Result<String> registerDevice(@RequestBody DeviceRegisterDTO deviceRegisterDTO) {
+        String macAddress = deviceRegisterDTO.getMacAddress();
+        if (StringUtils.isBlank(macAddress)) {
+            return new Result<String>().error(ErrorCode.NOT_NULL, "mac地址不能为空");
+        }
+        // 生成六位验证码
+        String code = String.valueOf(Math.random()).substring(2, 8);
+        String key = RedisKeys.getDeviceCaptchaKey(code);
+        String existsMac = null;
+        do {
+            existsMac = (String) redisUtils.get(key);
+        } while (StringUtils.isNotBlank(existsMac));
+
+        redisUtils.set(key, macAddress);
+        return new Result<String>().ok(code);
+    }
+
     @GetMapping("/bind/{agentId}")
     @Operation(summary = "获取已绑定设备")
     @RequiresPermissions("sys:role:normal")
@@ -66,4 +80,16 @@ public class DeviceController {
         return new Result<Void>();
     }
 
+    @PutMapping("/enableOta/{id}/{status}")
+    @Operation(summary = "启用/关闭OTA自动升级")
+    @RequiresPermissions("sys:role:normal")
+    public Result<Void> enableOtaUpgrade(@PathVariable String id, @PathVariable Integer status) {
+        DeviceEntity entity = deviceService.selectById(id);
+        if (entity == null) {
+            return new Result<Void>().error("设备不存在");
+        }
+        entity.setAutoUpdate(status);
+        deviceService.updateById(entity);
+        return new Result<Void>();
+    }
 }

main/manager-api/src/main/java/xiaozhi/modules/device/controller/OTAController.java

@@ -10,55 +10,83 @@ import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestHeader;
 import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 
 import com.fasterxml.jackson.annotation.JsonInclude;
 import com.fasterxml.jackson.databind.ObjectMapper;
 
+import io.swagger.v3.oas.annotations.Hidden;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.Parameter;
 import io.swagger.v3.oas.annotations.enums.ParameterIn;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
 import lombok.SneakyThrows;
-import xiaozhi.common.utils.Result;
+import lombok.extern.slf4j.Slf4j;
+import xiaozhi.common.constant.Constant;
 import xiaozhi.modules.device.dto.DeviceReportReqDTO;
 import xiaozhi.modules.device.dto.DeviceReportRespDTO;
+import xiaozhi.modules.device.entity.DeviceEntity;
 import xiaozhi.modules.device.service.DeviceService;
-import xiaozhi.modules.device.utils.NetworkUtil;
+import xiaozhi.modules.sys.service.SysParamsService;
 
 @Tag(name = "设备管理", description = "OTA 相关接口")
+@Slf4j
 @RestController
 @RequiredArgsConstructor
-@RequestMapping("/ota")
+@RequestMapping("/ota/")
 public class OTAController {
     private final DeviceService deviceService;
+    private final SysParamsService sysParamsService;
 
-    @Operation(summary = "检查 OTA 版本和设备激活状态")
+    @Operation(summary = "OTA版本和设备激活状态检查")
     @PostMapping
     public ResponseEntity<String> checkOTAVersion(
             @RequestBody DeviceReportReqDTO deviceReportReqDTO,
-
             @Parameter(name = "Device-Id", description = "设备唯一标识", required = true, in = ParameterIn.HEADER) @RequestHeader("Device-Id") String deviceId,
-
-            @Parameter(name = "Client-Id", description = "客户端标识", required = true, in = ParameterIn.HEADER) @RequestHeader("Client-Id") String clientId) {
-        if (StringUtils.isAnyBlank(deviceId, clientId)) {
+            @Parameter(name = "Client-Id", description = "客户端标识", required = false, in = ParameterIn.HEADER) @RequestHeader(value = "Client-Id", required = false) String clientId) {
+        if (StringUtils.isBlank(deviceId)) {
             return createResponse(DeviceReportRespDTO.createError("Device ID is required"));
         }
+        if (StringUtils.isBlank(clientId)) {
+            clientId = deviceId;
+        }
         String macAddress = deviceReportReqDTO.getMacAddress();
-        boolean macAddressValid = NetworkUtil.isMacAddressValid(macAddress);
+        boolean macAddressValid = isMacAddressValid(macAddress);
         // 设备Id和Mac地址应是一致的, 并且必须需要application字段
         if (!deviceId.equals(macAddress) || !macAddressValid || deviceReportReqDTO.getApplication() == null) {
             return createResponse(DeviceReportRespDTO.createError("Invalid OTA request"));
         }
-        return createResponse(deviceService.checkDeviceActive(macAddress, deviceId, clientId, deviceReportReqDTO));
+        return createResponse(deviceService.checkDeviceActive(macAddress, clientId, deviceReportReqDTO));
     }
 
-    @Operation(summary = "设备激活")
-    @GetMapping("/activation")
-    public Result<Boolean> deviceActivation(@RequestParam String code) {
-        return new Result<Boolean>().ok(deviceService.deviceActivation(code));
+    @Operation(summary = "设备快速检查激活状态")
+    @PostMapping("activate")
+    public ResponseEntity<String> activateDevice(
+            @Parameter(name = "Device-Id", description = "设备唯一标识", required = true, in = ParameterIn.HEADER) @RequestHeader("Device-Id") String deviceId,
+            @Parameter(name = "Client-Id", description = "客户端标识", required = false, in = ParameterIn.HEADER) @RequestHeader(value = "Client-Id", required = false) String clientId) {
+        if (StringUtils.isBlank(deviceId)) {
+            return ResponseEntity.status(202).build();
+        }
+        DeviceEntity device = deviceService.getDeviceByMacAddress(deviceId);
+        if (device == null) {
+            return ResponseEntity.status(202).build();
+        }
+        return ResponseEntity.ok("success");
+    }
+
+    @GetMapping
+    @Hidden
+    public ResponseEntity<String> getOTA() {
+        String wsUrl = sysParamsService.getValue(Constant.SERVER_WEBSOCKET, true);
+        if (StringUtils.isBlank(wsUrl) || wsUrl.equals("null")) {
+            return ResponseEntity.ok("OTA接口不正常，缺少websocket地址，请登录智控台，在参数管理找到【server.websocket】配置");
+        }
+        String otaUrl = sysParamsService.getValue(Constant.SERVER_OTA, true);
+        if (StringUtils.isBlank(otaUrl) || otaUrl.equals("null")) {
+            return ResponseEntity.ok("OTA接口不正常，缺少ota地址，请登录智控台，在参数管理找到【server.ota】配置");
+        }
+        return ResponseEntity.ok("OTA接口运行正常，websocket集群数量：" + wsUrl.split(";").length);
     }
 
     @SneakyThrows
@@ -73,4 +101,19 @@ public class OTAController {
                 .contentLength(jsonBytes.length)
                 .body(json);
     }
+
+    /**
+     * 简单判断mac地址是否有效（非严格）
+     * 
+     * @param macAddress
+     * @return
+     */
+    private boolean isMacAddressValid(String macAddress) {
+        if (StringUtils.isBlank(macAddress)) {
+            return false;
+        }
+        // MAC地址通常为12位十六进制数字，可以包含冒号或连字符分隔符
+        String macPattern = "^([0-9A-Za-z]{2}[:-]){5}([0-9A-Za-z]{2})$";
+        return macAddress.matches(macPattern);
+    }
 }

main/manager-api/src/main/java/xiaozhi/modules/device/controller/OTAMagController.java

@@ -0,0 +1,291 @@
+package xiaozhi.modules.device.controller;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Map;
+import java.util.UUID;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.shiro.authz.annotation.RequiresPermissions;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.multipart.MultipartFile;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.Parameters;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import xiaozhi.common.constant.Constant;
+import xiaozhi.common.page.PageData;
+import xiaozhi.common.redis.RedisKeys;
+import xiaozhi.common.redis.RedisUtils;
+import xiaozhi.common.utils.Result;
+import xiaozhi.common.validator.ValidatorUtils;
+import xiaozhi.modules.device.entity.OtaEntity;
+import xiaozhi.modules.device.service.OtaService;
+
+@Tag(name = "设备管理", description = "OTA 相关接口")
+@Slf4j
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/otaMag")
+public class OTAMagController {
+    private static final Logger logger = LoggerFactory.getLogger(OTAController.class);
+    private final OtaService otaService;
+    private final RedisUtils redisUtils;
+
+    @GetMapping
+    @Operation(summary = "分页查询 OTA 固件信息")
+    @Parameters({
+            @Parameter(name = Constant.PAGE, description = "当前页码，从1开始", required = true),
+            @Parameter(name = Constant.LIMIT, description = "每页显示记录数", required = true)
+    })
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<PageData<OtaEntity>> page(@Parameter(hidden = true) @RequestParam Map<String, Object> params) {
+        ValidatorUtils.validateEntity(params);
+        PageData<OtaEntity> page = otaService.page(params);
+        return new Result<PageData<OtaEntity>>().ok(page);
+    }
+
+    @GetMapping("{id}")
+    @Operation(summary = "信息 OTA 固件信息")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<OtaEntity> get(@PathVariable("id") String id) {
+        OtaEntity data = otaService.selectById(id);
+        return new Result<OtaEntity>().ok(data);
+    }
+
+    @PostMapping
+    @Operation(summary = "保存 OTA 固件信息")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<Void> save(@RequestBody OtaEntity entity) {
+        if (entity == null) {
+            return new Result<Void>().error("固件信息不能为空");
+        }
+        if (StringUtils.isBlank(entity.getFirmwareName())) {
+            return new Result<Void>().error("固件名称不能为空");
+        }
+        if (StringUtils.isBlank(entity.getType())) {
+            return new Result<Void>().error("固件类型不能为空");
+        }
+        if (StringUtils.isBlank(entity.getVersion())) {
+            return new Result<Void>().error("版本号不能为空");
+        }
+        try {
+            otaService.save(entity);
+            return new Result<Void>();
+        } catch (RuntimeException e) {
+            return new Result<Void>().error(e.getMessage());
+        }
+    }
+
+    @DeleteMapping("/{id}")
+    @Operation(summary = "OTA 删除")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<Void> delete(@PathVariable("id") String[] ids) {
+        if (ids == null || ids.length == 0) {
+            return new Result<Void>().error("删除的固件ID不能为空");
+        }
+        otaService.delete(ids);
+        return new Result<Void>();
+    }
+
+    @PutMapping("/{id}")
+    @Operation(summary = "修改 OTA 固件信息")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<?> update(@PathVariable("id") String id, @RequestBody OtaEntity entity) {
+        if (entity == null) {
+            return new Result<>().error("固件信息不能为空");
+        }
+        entity.setId(id);
+        try {
+            otaService.update(entity);
+            return new Result<>();
+        } catch (RuntimeException e) {
+            return new Result<>().error(e.getMessage());
+        }
+    }
+
+    @GetMapping("/getDownloadUrl/{id}")
+    @Operation(summary = "获取 OTA 固件下载链接")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<String> getDownloadUrl(@PathVariable("id") String id) {
+        String uuid = UUID.randomUUID().toString();
+        redisUtils.set(RedisKeys.getOtaIdKey(uuid), id);
+        return new Result<String>().ok(uuid);
+    }
+
+    @GetMapping("/download/{uuid}")
+    @Operation(summary = "下载固件文件")
+    public ResponseEntity<byte[]> downloadFirmware(@PathVariable("uuid") String uuid) {
+        String id = (String) redisUtils.get(RedisKeys.getOtaIdKey(uuid));
+        if (StringUtils.isBlank(id)) {
+            return ResponseEntity.notFound().build();
+        }
+
+        // 检查下载次数
+        String downloadCountKey = RedisKeys.getOtaDownloadCountKey(uuid);
+        Integer downloadCount = (Integer) redisUtils.get(downloadCountKey);
+        if (downloadCount == null) {
+            downloadCount = 0;
+        }
+
+        // 如果下载次数超过3次，返回404
+        if (downloadCount >= 3) {
+            redisUtils.delete(downloadCountKey);
+            redisUtils.delete(RedisKeys.getOtaIdKey(uuid));
+            logger.warn("Download limit exceeded for UUID: {}", uuid);
+            return ResponseEntity.notFound().build();
+        }
+
+        redisUtils.set(downloadCountKey, downloadCount + 1);
+
+        try {
+            // 获取固件信息
+            OtaEntity otaEntity = otaService.selectById(id);
+            if (otaEntity == null || StringUtils.isBlank(otaEntity.getFirmwarePath())) {
+                logger.warn("Firmware not found or path is empty for ID: {}", id);
+                return ResponseEntity.notFound().build();
+            }
+
+            // 获取文件路径 - 确保路径是绝对路径或正确的相对路径
+            String firmwarePath = otaEntity.getFirmwarePath();
+            Path path;
+
+            // 检查是否是绝对路径
+            if (Paths.get(firmwarePath).isAbsolute()) {
+                path = Paths.get(firmwarePath);
+            } else {
+                // 如果是相对路径，则从当前工作目录解析
+                path = Paths.get(System.getProperty("user.dir"), firmwarePath);
+            }
+
+            logger.info("Attempting to download firmware for ID: {}, DB path: {}, resolved path: {}",
+                    id, firmwarePath, path.toAbsolutePath());
+
+            if (!Files.exists(path) || !Files.isRegularFile(path)) {
+                // 尝试直接从firmware目录下查找文件名
+                String fileName = new File(firmwarePath).getName();
+                Path altPath = Paths.get(System.getProperty("user.dir"), "firmware", fileName);
+
+                logger.info("File not found at primary path, trying alternative path: {}", altPath.toAbsolutePath());
+
+                if (Files.exists(altPath) && Files.isRegularFile(altPath)) {
+                    path = altPath;
+                } else {
+                    logger.error("Firmware file not found at either path: {} or {}",
+                            path.toAbsolutePath(), altPath.toAbsolutePath());
+                    return ResponseEntity.notFound().build();
+                }
+            }
+
+            // 读取文件内容
+            byte[] fileContent = Files.readAllBytes(path);
+
+            // 设置响应头
+            String originalFilename = otaEntity.getType() + "_" + otaEntity.getVersion();
+            if (firmwarePath.contains(".")) {
+                String extension = firmwarePath.substring(firmwarePath.lastIndexOf("."));
+                originalFilename += extension;
+            }
+
+            // 清理文件名，移除不安全字符
+            String safeFilename = originalFilename.replaceAll("[^a-zA-Z0-9._-]", "_");
+
+            logger.info("Providing download for firmware ID: {}, filename: {}, size: {} bytes",
+                    id, safeFilename, fileContent.length);
+
+            return ResponseEntity.ok()
+                    .contentType(MediaType.APPLICATION_OCTET_STREAM)
+                    .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + safeFilename + "\"")
+                    .body(fileContent);
+        } catch (IOException e) {
+            logger.error("Error reading firmware file for ID: {}", id, e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        } catch (Exception e) {
+            logger.error("Unexpected error during firmware download for ID: {}", id, e);
+            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+        }
+    }
+
+    @PostMapping("/upload")
+    @Operation(summary = "上传固件文件")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<String> uploadFirmware(@RequestParam("file") MultipartFile file) {
+        if (file.isEmpty()) {
+            return new Result<String>().error("上传文件不能为空");
+        }
+
+        // 检查文件扩展名
+        String originalFilename = file.getOriginalFilename();
+        if (originalFilename == null) {
+            return new Result<String>().error("文件名不能为空");
+        }
+
+        String extension = originalFilename.substring(originalFilename.lastIndexOf(".")).toLowerCase();
+        if (!extension.equals(".bin") && !extension.equals(".apk")) {
+            return new Result<String>().error("只允许上传.bin和.apk格式的文件");
+        }
+
+        try {
+            // 计算文件的MD5值
+            String md5 = calculateMD5(file);
+
+            // 设置存储路径
+            String uploadDir = "uploadfile";
+            Path uploadPath = Paths.get(uploadDir);
+
+            // 如果目录不存在，创建目录
+            if (!Files.exists(uploadPath)) {
+                Files.createDirectories(uploadPath);
+            }
+
+            // 使用MD5作为文件名，固定使用.bin扩展名
+            String uniqueFileName = md5 + extension;
+            Path filePath = uploadPath.resolve(uniqueFileName);
+
+            // 检查文件是否已存在
+            if (Files.exists(filePath)) {
+                return new Result<String>().ok(filePath.toString());
+            }
+
+            // 保存文件
+            Files.copy(file.getInputStream(), filePath);
+
+            // 返回文件路径
+            return new Result<String>().ok(filePath.toString());
+        } catch (IOException | NoSuchAlgorithmException e) {
+            return new Result<String>().error("文件上传失败：" + e.getMessage());
+        }
+    }
+
+    private String calculateMD5(MultipartFile file) throws IOException, NoSuchAlgorithmException {
+        MessageDigest md = MessageDigest.getInstance("MD5");
+        byte[] digest = md.digest(file.getBytes());
+        StringBuilder sb = new StringBuilder();
+        for (byte b : digest) {
+            sb.append(String.format("%02x", b));
+        }
+        return sb.toString();
+    }
+}

main/manager-api/src/main/java/xiaozhi/modules/device/dao/DeviceDao.java

@@ -1,5 +1,7 @@
 package xiaozhi.modules.device.dao;
 
+import java.util.Date;
+
 import org.apache.ibatis.annotations.Mapper;
 
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
@@ -8,4 +10,12 @@ import xiaozhi.modules.device.entity.DeviceEntity;
 
 @Mapper
 public interface DeviceDao extends BaseMapper<DeviceEntity> {
+    /**
+     * 获取此智能体全部设备的最后连接时间
+     * 
+     * @param agentId 智能体id
+     * @return
+     */
+    Date getAllLastConnectedAtByAgentId(String agentId);
+
 }

main/manager-api/src/main/java/xiaozhi/modules/device/dao/OtaDao.java

@@ -0,0 +1,15 @@
+package xiaozhi.modules.device.dao;
+
+import org.apache.ibatis.annotations.Mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+import xiaozhi.modules.device.entity.OtaEntity;
+
+/**
+ * OTA固件管理
+ */
+@Mapper
+public interface OtaDao extends BaseMapper<OtaEntity> {
+    
+}

main/manager-api/src/main/java/xiaozhi/modules/device/dto/DevicePageUserDTO.java

@@ -0,0 +1,27 @@
+package xiaozhi.modules.device.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.Min;
+import lombok.Data;
+
+/**
+ * 查询所有设备的DTO
+ * 
+ * @author zjy
+ * @since 2025-3-21
+ */
+@Data
+@Schema(description = "查询所有设备的DTO")
+public class DevicePageUserDTO {
+
+    @Schema(description = "设备关键词")
+    private String keywords;
+
+    @Schema(description = "页数")
+    @Min(value = 0, message = "{page.number}")
+    private String page;
+
+    @Schema(description = "显示列数")
+    @Min(value = 0, message = "{limit.number}")
+    private String limit;
+}

main/manager-api/src/main/java/xiaozhi/modules/device/dto/DeviceRegisterDTO.java

@@ -0,0 +1,23 @@
+package xiaozhi.modules.device.dto;
+
+import java.io.Serializable;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * 设备注册头信息
+ * 
+ * @author zjy
+ * @since 2025-3-28
+ */
+@Setter
+@Getter
+@Schema(description = "设备注册头信息")
+public class DeviceRegisterDTO implements Serializable {
+
+    @Schema(description = "mac地址")
+    private String macAddress;
+
+}

main/manager-api/src/main/java/xiaozhi/modules/device/dto/DeviceReportRespDTO.java

@@ -9,7 +9,7 @@ import lombok.Setter;
 @Schema(description = "设备OTA检测版本返回体，包含激活码要求")
 public class DeviceReportRespDTO {
     @Schema(description = "服务器时间")
-    private ServerTime serverTime;
+    private ServerTime server_time;
 
     @Schema(description = "激活码")
     private Activation activation;
@@ -19,6 +19,9 @@ public class DeviceReportRespDTO {
 
     @Schema(description = "固件版本信息")
     private Firmware firmware;
+    
+    @Schema(description = "WebSocket配置")
+    private Websocket websocket;
 
     @Getter
     @Setter
@@ -44,6 +47,8 @@ public class DeviceReportRespDTO {
         @Schema(description = "激活码信息: 激活地址")
         private String message;
 
+        @Schema(description = "挑战码")
+        private String challenge;
     }
 
     @Getter
@@ -56,6 +61,13 @@ public class DeviceReportRespDTO {
         private String timeZone;
 
         @Schema(description = "时区偏移量，单位为分钟")
-        private Integer timezoneOffset;
+        private Integer timezone_offset;
+    }
+    
+    @Getter
+    @Setter
+    public static class Websocket {
+        @Schema(description = "WebSocket服务器地址")
+        private String url;
     }
 }

main/manager-api/src/main/java/xiaozhi/modules/device/entity/OtaEntity.java

@@ -0,0 +1,61 @@
+package xiaozhi.modules.device.entity;
+
+import java.util.Date;
+
+import com.baomidou.mybatisplus.annotation.FieldFill;
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+@Data
+@EqualsAndHashCode(callSuper = false)
+@TableName("ai_ota")
+@Schema(description = "固件信息")
+public class OtaEntity {
+
+    @TableId(type = IdType.ASSIGN_UUID)
+    @Schema(description = "ID")
+    private String id;
+
+    @Schema(description = "固件名称")
+    private String firmwareName;
+
+    @Schema(description = "固件类型")
+    private String type;
+
+    @Schema(description = "版本号")
+    private String version;
+
+    @Schema(description = "文件大小(字节)")
+    private Long size;
+
+    @Schema(description = "备注/说明")
+    private String remark;
+
+    @Schema(description = "固件路径")
+    private String firmwarePath;
+
+    @Schema(description = "排序")
+    private Integer sort;
+
+    @Schema(description = "更新者")
+    @TableField(fill = FieldFill.UPDATE)
+    private Long updater;
+
+    @Schema(description = "更新时间")
+    @TableField(fill = FieldFill.UPDATE)
+    private Date updateDate;
+
+    @Schema(description = "创建者")
+    @TableField(fill = FieldFill.INSERT)
+    private Long creator;
+
+    @Schema(description = "创建时间")
+    @TableField(fill = FieldFill.INSERT)
+    private Date createDate;
+}

main/manager-api/src/main/java/xiaozhi/modules/device/service/DeviceService.java

@@ -1,32 +1,26 @@
 package xiaozhi.modules.device.service;
 
+import java.util.Date;
 import java.util.List;
 
-import xiaozhi.modules.device.dto.DeviceBindDTO;
+import xiaozhi.common.page.PageData;
+import xiaozhi.common.service.BaseService;
+import xiaozhi.modules.device.dto.DevicePageUserDTO;
 import xiaozhi.modules.device.dto.DeviceReportReqDTO;
 import xiaozhi.modules.device.dto.DeviceReportRespDTO;
 import xiaozhi.modules.device.entity.DeviceEntity;
+import xiaozhi.modules.device.vo.UserShowDeviceListVO;
 
-public interface DeviceService {
-
-    /**
-     * 根据Mac地址获取设备信息
-     */
-    DeviceEntity getDeviceById(String macAddress);
+public interface DeviceService extends BaseService<DeviceEntity> {
 
     /**
      * 检查设备是否激活
      */
-    DeviceReportRespDTO checkDeviceActive(String macAddress, String deviceId, String clientId,
+    DeviceReportRespDTO checkDeviceActive(String macAddress, String clientId,
             DeviceReportReqDTO deviceReport);
 
     /**
-     * 绑定设备
-     */
-    DeviceEntity bindDevice(DeviceBindDTO deviceHeader);
-
-    /**
-     * 获取用户设备列表
+     * 获取用户指定智能体的设备列表，
      */
     List<DeviceEntity> getUserDevices(Long userId, String agentId);
 
@@ -38,5 +32,60 @@ public interface DeviceService {
     /**
      * 设备激活
      */
-    Boolean deviceActivation(String activationCode);
+    Boolean deviceActivation(String agentId, String activationCode);
+
+    /**
+     * 删除此用户的所有设备
+     * 
+     * @param userId 用户id
+     */
+    void deleteByUserId(Long userId);
+
+    /**
+     * 删除指定智能体关联的所有设备
+     * 
+     * @param agentId 智能体id
+     */
+    void deleteByAgentId(String agentId);
+
+    /**
+     * 获取指定用户的设备数量
+     * 
+     * @param userId 用户id
+     * @return 设备数量
+     */
+    Long selectCountByUserId(Long userId);
+
+    /**
+     * 分页获取全部设备信息
+     *
+     * @param dto 分页查找参数
+     * @return 用户列表分页数据
+     */
+    PageData<UserShowDeviceListVO> page(DevicePageUserDTO dto);
+
+    /**
+     * 根据MAC地址获取设备信息
+     * 
+     * @param macAddress MAC地址
+     * @return 设备信息
+     */
+    DeviceEntity getDeviceByMacAddress(String macAddress);
+
+    /**
+     * 根据设备ID获取激活码
+     * 
+     * @param deviceId 设备ID
+     * @return 激活码
+     */
+    String geCodeByDeviceId(String deviceId);
+
+    /**
+     * 获取这个智能体设备理的最近的最后连接时间
+     * @param agentId 智能体id
+     * @return 返回设备最近的最后连接时间
+     */
+    Date getLatestLastConnectionTime(String agentId);
+
+
 }

main/manager-api/src/main/java/xiaozhi/modules/device/service/OtaService.java

@@ -0,0 +1,22 @@
+package xiaozhi.modules.device.service;
+
+import java.util.Map;
+
+import xiaozhi.common.page.PageData;
+import xiaozhi.common.service.BaseService;
+import xiaozhi.modules.device.entity.OtaEntity;
+
+/**
+ * OTA固件管理
+ */
+public interface OtaService extends BaseService<OtaEntity> {
+    PageData<OtaEntity> page(Map<String, Object> params);
+
+    boolean save(OtaEntity entity);
+
+    void update(OtaEntity entity);
+
+    void delete(String[] ids);
+
+    OtaEntity getLatestOta(String type);
+}

main/manager-api/src/main/java/xiaozhi/modules/device/service/impl/DeviceServiceImpl.java

@@ -6,69 +6,68 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.TimeZone;
-import java.util.concurrent.TimeUnit;
+import java.util.UUID;
 
 import org.apache.commons.lang3.StringUtils;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.stereotype.Service;
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
 
-import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
 
 import cn.hutool.core.util.RandomUtil;
+import jakarta.servlet.http.HttpServletRequest;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import xiaozhi.common.constant.Constant;
 import xiaozhi.common.exception.RenException;
+import xiaozhi.common.page.PageData;
+import xiaozhi.common.redis.RedisKeys;
+import xiaozhi.common.redis.RedisUtils;
 import xiaozhi.common.service.impl.BaseServiceImpl;
 import xiaozhi.common.user.UserDetail;
 import xiaozhi.common.utils.ConvertUtils;
+import xiaozhi.common.utils.DateUtils;
 import xiaozhi.modules.device.dao.DeviceDao;
-import xiaozhi.modules.device.dto.DeviceBindDTO;
+import xiaozhi.modules.device.dto.DevicePageUserDTO;
 import xiaozhi.modules.device.dto.DeviceReportReqDTO;
 import xiaozhi.modules.device.dto.DeviceReportRespDTO;
 import xiaozhi.modules.device.entity.DeviceEntity;
+import xiaozhi.modules.device.entity.OtaEntity;
 import xiaozhi.modules.device.service.DeviceService;
+import xiaozhi.modules.device.service.OtaService;
+import xiaozhi.modules.device.vo.UserShowDeviceListVO;
 import xiaozhi.modules.security.user.SecurityUser;
+import xiaozhi.modules.sys.service.SysParamsService;
+import xiaozhi.modules.sys.service.SysUserUtilService;
 
+@Slf4j
 @Service
+@AllArgsConstructor
 public class DeviceServiceImpl extends BaseServiceImpl<DeviceDao, DeviceEntity> implements DeviceService {
 
     private final DeviceDao deviceDao;
-
-    private final String frontedUrl;
-
-    private final RedisTemplate<String, Object> redisTemplate;
-
-    // 添加构造函数来初始化 deviceMapper
-    public DeviceServiceImpl(DeviceDao deviceDao,
-            @Value("${app.fronted-url:http://localhost:8001}") String frontedUrl,
-            RedisTemplate<String, Object> redisTemplate) {
-        this.deviceDao = deviceDao;
-        this.frontedUrl = frontedUrl;
-        this.redisTemplate = redisTemplate;
-    }
+    private final SysUserUtilService sysUserUtilService;
+    private final SysParamsService sysParamsService;
+    private final RedisUtils redisUtils;
+    private final OtaService otaService;
 
     @Override
-    public DeviceEntity getDeviceById(String deviceId) {
-        LambdaQueryWrapper<DeviceEntity> queryWrapper = new LambdaQueryWrapper<>();
-        queryWrapper.eq(DeviceEntity::getId, deviceId);
-        return deviceDao.selectOne(queryWrapper);
-    }
-
-    @Override
-    public Boolean deviceActivation(String activationCode) {
+    public Boolean deviceActivation(String agentId, String activationCode) {
         if (StringUtils.isBlank(activationCode)) {
             throw new RenException("激活码不能为空");
         }
         String deviceKey = "ota:activation:code:" + activationCode;
-        Object cacheDeviceId = redisTemplate.opsForValue().get(deviceKey);
+        Object cacheDeviceId = redisUtils.get(deviceKey);
         if (cacheDeviceId == null) {
             throw new RenException("激活码错误");
         }
         String deviceId = (String) cacheDeviceId;
         String safeDeviceId = deviceId.replace(":", "_").toLowerCase();
         String cacheDeviceKey = String.format("ota:activation:data:%s", safeDeviceId);
-        Map<Object, Object> cacheMap = redisTemplate.opsForHash().entries(cacheDeviceKey);
+        Map<String, Object> cacheMap = (Map<String, Object>) redisUtils.get(cacheDeviceKey);
         if (cacheMap == null) {
             throw new RenException("激活码错误");
         }
@@ -93,10 +92,12 @@ public class DeviceServiceImpl extends BaseServiceImpl<DeviceDao, DeviceEntity>
         DeviceEntity deviceEntity = new DeviceEntity();
         deviceEntity.setId(deviceId);
         deviceEntity.setBoard(board);
+        deviceEntity.setAgentId(agentId);
         deviceEntity.setAppVersion(appVersion);
         deviceEntity.setMacAddress(macAddress);
         deviceEntity.setUserId(user.getId());
         deviceEntity.setCreator(user.getId());
+        deviceEntity.setAutoUpdate(1);
         deviceEntity.setCreateDate(currentTime);
         deviceEntity.setUpdater(user.getId());
         deviceEntity.setUpdateDate(currentTime);
@@ -104,83 +105,67 @@ public class DeviceServiceImpl extends BaseServiceImpl<DeviceDao, DeviceEntity>
         deviceDao.insert(deviceEntity);
 
         // 清理redis缓存
-        redisTemplate.delete(cacheDeviceKey);
-        redisTemplate.delete(deviceKey);
+        redisUtils.delete(cacheDeviceKey);
+        redisUtils.delete(deviceKey);
         return true;
     }
 
     @Override
-    public DeviceReportRespDTO checkDeviceActive(String macAddress, String deviceId, String clientId,
+    public DeviceReportRespDTO checkDeviceActive(String macAddress, String clientId,
             DeviceReportReqDTO deviceReport) {
         DeviceReportRespDTO response = new DeviceReportRespDTO();
-        response.setServerTime(buildServerTime());
-        // todo: 此处是固件信息，目前是针对固件上传上来的版本号再返回回去
-        // 在未来开发了固件更新功能，需要更换此处代码，
-        // 或写定时任务定期请求虾哥的OTA，获取最新的版本讯息保存到服务内
-        DeviceReportRespDTO.Firmware firmware = new DeviceReportRespDTO.Firmware();
-        firmware.setVersion(deviceReport.getApplication().getVersion());
-        firmware.setUrl("http://localhost:8002/xiaozhi-esp32-api/api/v1/ota/download");
-        response.setFirmware(firmware);
+        response.setServer_time(buildServerTime());
 
-        DeviceEntity deviceById = getDeviceById(deviceId);
-        if (deviceById != null) { // 如果设备存在，则更新上次连接时间
-            deviceById.setLastConnectedAt(new Date());
-            deviceDao.updateById(deviceById);
-        } else { // 如果设备不存在，则生成激活码
-            String safeDeviceId = deviceId.replace(":", "_").toLowerCase();
-            String dataKey = String.format("ota:activation:data:%s", safeDeviceId);
+        DeviceEntity deviceById = getDeviceByMacAddress(macAddress);
 
-            Map<Object, Object> cacheMap = redisTemplate.opsForHash().entries(dataKey);
-            DeviceReportRespDTO.Activation code = new DeviceReportRespDTO.Activation();
+        // 只有在设备已绑定且autoUpdate不为0的情况下才返回固件升级信息
+        if (deviceById != null && deviceById.getAutoUpdate() != 0) {
+            String type = deviceReport.getBoard() == null ? null : deviceReport.getBoard().getType();
+            DeviceReportRespDTO.Firmware firmware = buildFirmwareInfo(type,
+                    deviceReport.getApplication() == null ? null : deviceReport.getApplication().getVersion());
+            response.setFirmware(firmware);
+        } else {
+            response.setFirmware(null);
+        }
 
-            if (cacheMap != null && cacheMap.containsKey("activation_code")) {
-                String cachedCode = (String) cacheMap.get("activation_code");
-                code.setCode(cachedCode);
-                code.setMessage(frontedUrl + "\n" + cachedCode);
+        // 添加WebSocket配置
+        DeviceReportRespDTO.Websocket websocket = new DeviceReportRespDTO.Websocket();
+        // 从系统参数获取WebSocket URL，如果未配置则使用默认值
+        String wsUrl = sysParamsService.getValue(Constant.SERVER_WEBSOCKET, true);
+        if (StringUtils.isBlank(wsUrl) || wsUrl.equals("null")) {
+            log.error("WebSocket地址未配置，请登录智控台，在参数管理找到【server.websocket】配置");
+            wsUrl = "ws://xiaozhi.server.com:8000/xiaozhi/v1/";
+            websocket.setUrl(wsUrl);
+        } else {
+            String[] wsUrls = wsUrl.split("\\;");
+            if (wsUrls.length > 0) {
+                // 随机选择一个WebSocket URL
+                websocket.setUrl(wsUrls[RandomUtil.randomInt(0, wsUrls.length)]);
             } else {
-                String newCode = RandomUtil.randomNumbers(6);
-                code.setCode(newCode);
-                code.setMessage(frontedUrl + "\n" + newCode);
-
-                Map<String, Object> dataMap = new HashMap<>();
-                dataMap.put("id", deviceId);
-                dataMap.put("mac_address", macAddress);
-                dataMap.put("board", (deviceReport.getChipModelName() != null) ? deviceReport.getChipModelName()
-                        : (deviceReport.getBoard() != null ? deviceReport.getBoard().getType() : "unknown"));
-                dataMap.put("app_version", (deviceReport.getApplication() != null)
-                        ? deviceReport.getApplication().getVersion()
-                        : null);
-                dataMap.put("deviceId", deviceId);
-                dataMap.put("activation_code", newCode);
-
-                // 写入主数据 key
-                redisTemplate.opsForHash().putAll(dataKey, dataMap);
-                redisTemplate.expire(dataKey, 24, TimeUnit.HOURS);
-
-                // 写入反查激活码 key
-                String codeKey = "ota:activation:code:" + newCode;
-                redisTemplate.opsForValue().set(codeKey, deviceId, 24, TimeUnit.HOURS);
+                log.error("WebSocket地址未配置，请登录智控台，在参数管理找到【server.websocket】配置");
+                websocket.setUrl("ws://xiaozhi.server.com:8000/xiaozhi/v1/");
             }
+        }
 
+        response.setWebsocket(websocket);
+
+        if (deviceById != null) {
+            // 如果设备存在，则更新上次连接时间
+            deviceById.setLastConnectedAt(new Date());
+            if (deviceReport.getApplication() != null
+                    && StringUtils.isNotBlank(deviceReport.getApplication().getVersion())) {
+                deviceById.setAppVersion(deviceReport.getApplication().getVersion());
+            }
+            deviceDao.updateById(deviceById);
+        } else {
+            // 如果设备不存在，则生成激活码
+            DeviceReportRespDTO.Activation code = buildActivation(macAddress, deviceReport);
             response.setActivation(code);
         }
 
         return response;
     }
 
-    @Override
-    public DeviceEntity bindDevice(DeviceBindDTO dto) {
-        // 查看是否已经被绑定
-        DeviceEntity deviceEntity = baseDao
-                .selectOne(new LambdaQueryWrapper<DeviceEntity>().eq(DeviceEntity::getMacAddress, dto.getMacAddress()));
-        if (deviceEntity != null) {
-            throw new RenException("设备已绑定");
-        }
-        deviceEntity = ConvertUtils.sourceToTarget(dto, DeviceEntity.class);
-        baseDao.insert(deviceEntity);
-        return deviceEntity;
-    }
-
     @Override
     public List<DeviceEntity> getUserDevices(Long userId, String agentId) {
         QueryWrapper<DeviceEntity> wrapper = new QueryWrapper<>();
@@ -197,12 +182,207 @@ public class DeviceServiceImpl extends BaseServiceImpl<DeviceDao, DeviceEntity>
         baseDao.delete(wrapper);
     }
 
+    @Override
+    public void deleteByUserId(Long userId) {
+        UpdateWrapper<DeviceEntity> wrapper = new UpdateWrapper<>();
+        wrapper.eq("user_id", userId);
+        baseDao.delete(wrapper);
+    }
+
+    @Override
+    public Long selectCountByUserId(Long userId) {
+        UpdateWrapper<DeviceEntity> wrapper = new UpdateWrapper<>();
+        wrapper.eq("user_id", userId);
+        return baseDao.selectCount(wrapper);
+    }
+
+    @Override
+    public void deleteByAgentId(String agentId) {
+        UpdateWrapper<DeviceEntity> wrapper = new UpdateWrapper<>();
+        wrapper.eq("agent_id", agentId);
+        baseDao.delete(wrapper);
+    }
+
+    @Override
+    public PageData<UserShowDeviceListVO> page(DevicePageUserDTO dto) {
+        Map<String, Object> params = new HashMap<String, Object>();
+        params.put(Constant.PAGE, dto.getPage());
+        params.put(Constant.LIMIT, dto.getLimit());
+        IPage<DeviceEntity> page = baseDao.selectPage(
+                getPage(params, "mac_address", true),
+                // 定义查询条件
+                new QueryWrapper<DeviceEntity>()
+                        // 必须设备关键词查找
+                        .like(StringUtils.isNotBlank(dto.getKeywords()), "alias", dto.getKeywords()));
+        // 循环处理page获取回来的数据，返回需要的字段
+        List<UserShowDeviceListVO> list = page.getRecords().stream().map(device -> {
+            UserShowDeviceListVO vo = ConvertUtils.sourceToTarget(device, UserShowDeviceListVO.class);
+            // 把最后修改的时间，改为简短描述的时间
+            vo.setRecentChatTime(DateUtils.getShortTime(device.getUpdateDate()));
+            sysUserUtilService.assignUsername(device.getUserId(),
+                    vo::setBindUserName);
+            vo.setDeviceType(device.getBoard());
+            return vo;
+        }).toList();
+        // 计算页数
+        return new PageData<>(list, page.getTotal());
+    }
+
+    @Override
+    public DeviceEntity getDeviceByMacAddress(String macAddress) {
+        if (StringUtils.isBlank(macAddress)) {
+            return null;
+        }
+        QueryWrapper<DeviceEntity> wrapper = new QueryWrapper<>();
+        wrapper.eq("mac_address", macAddress);
+        return baseDao.selectOne(wrapper);
+    }
+
     private DeviceReportRespDTO.ServerTime buildServerTime() {
         DeviceReportRespDTO.ServerTime serverTime = new DeviceReportRespDTO.ServerTime();
         TimeZone tz = TimeZone.getDefault();
         serverTime.setTimestamp(Instant.now().toEpochMilli());
         serverTime.setTimeZone(tz.getID());
-        serverTime.setTimezoneOffset(tz.getOffset(System.currentTimeMillis()) / (60 * 1000));
+        serverTime.setTimezone_offset(tz.getOffset(System.currentTimeMillis()) / (60 * 1000));
         return serverTime;
     }
+
+    @Override
+    public String geCodeByDeviceId(String deviceId) {
+        String dataKey = getDeviceCacheKey(deviceId);
+
+        Map<String, Object> cacheMap = (Map<String, Object>) redisUtils.get(dataKey);
+        if (cacheMap != null && cacheMap.containsKey("activation_code")) {
+            String cachedCode = (String) cacheMap.get("activation_code");
+            return cachedCode;
+        }
+        return null;
+    }
+
+    @Override
+    public Date getLatestLastConnectionTime(String agentId) {
+        // 查询是否有缓存时间，有则返回
+        Date cachedDate = (Date) redisUtils.get(RedisKeys.getAgentDeviceLastConnectedAtById(agentId));
+        if (cachedDate != null) {
+            return cachedDate;
+        }
+        Date maxDate = deviceDao.getAllLastConnectedAtByAgentId(agentId);
+        if (maxDate != null) {
+            redisUtils.set(RedisKeys.getAgentDeviceLastConnectedAtById(agentId), maxDate);
+        }
+        return maxDate;
+    }
+
+    private String getDeviceCacheKey(String deviceId) {
+        String safeDeviceId = deviceId.replace(":", "_").toLowerCase();
+        String dataKey = String.format("ota:activation:data:%s", safeDeviceId);
+        return dataKey;
+    }
+
+    public DeviceReportRespDTO.Activation buildActivation(String deviceId, DeviceReportReqDTO deviceReport) {
+        DeviceReportRespDTO.Activation code = new DeviceReportRespDTO.Activation();
+
+        String cachedCode = geCodeByDeviceId(deviceId);
+
+        if (StringUtils.isNotBlank(cachedCode)) {
+            code.setCode(cachedCode);
+            String frontedUrl = sysParamsService.getValue(Constant.SERVER_FRONTED_URL, true);
+            code.setMessage(frontedUrl + "\n" + cachedCode);
+            code.setChallenge(deviceId);
+        } else {
+            String newCode = RandomUtil.randomNumbers(6);
+            code.setCode(newCode);
+            String frontedUrl = sysParamsService.getValue(Constant.SERVER_FRONTED_URL, true);
+            code.setMessage(frontedUrl + "\n" + newCode);
+            code.setChallenge(deviceId);
+
+            Map<String, Object> dataMap = new HashMap<>();
+            dataMap.put("id", deviceId);
+            dataMap.put("mac_address", deviceId);
+
+            dataMap.put("board", (deviceReport.getBoard() != null && deviceReport.getBoard().getType() != null)
+                    ? deviceReport.getBoard().getType()
+                    : (deviceReport.getChipModelName() != null ? deviceReport.getChipModelName() : "unknown"));
+            dataMap.put("app_version", (deviceReport.getApplication() != null)
+                    ? deviceReport.getApplication().getVersion()
+                    : null);
+
+            dataMap.put("deviceId", deviceId);
+            dataMap.put("activation_code", newCode);
+
+            // 写入主数据 key
+            String dataKey = getDeviceCacheKey(deviceId);
+            redisUtils.set(dataKey, dataMap);
+
+            // 写入反查激活码 key
+            String codeKey = "ota:activation:code:" + newCode;
+            redisUtils.set(codeKey, deviceId);
+        }
+        return code;
+    }
+
+    private DeviceReportRespDTO.Firmware buildFirmwareInfo(String type, String currentVersion) {
+        if (StringUtils.isBlank(type)) {
+            return null;
+        }
+        if (StringUtils.isBlank(currentVersion)) {
+            currentVersion = "0.0.0";
+        }
+
+        OtaEntity ota = otaService.getLatestOta(type);
+        DeviceReportRespDTO.Firmware firmware = new DeviceReportRespDTO.Firmware();
+        String downloadUrl = null;
+
+        if (ota != null) {
+            // 如果设备没有版本信息，或者OTA版本比设备版本新，则返回下载地址
+            if (compareVersions(ota.getVersion(), currentVersion) > 0) {
+                String otaUrl = sysParamsService.getValue(Constant.SERVER_OTA, true);
+                if (StringUtils.isBlank(otaUrl) || otaUrl.equals("null")) {
+                    log.error("OTA地址未配置，请登录智控台，在参数管理找到【server.ota】配置");
+                    // 尝试从请求中获取
+                    HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder
+                            .getRequestAttributes())
+                            .getRequest();
+                    otaUrl = request.getRequestURL().toString();
+                }
+                // 将URL中的/ota/替换为/otaMag/download/
+                String uuid = UUID.randomUUID().toString();
+                redisUtils.set(RedisKeys.getOtaIdKey(uuid), ota.getId());
+                downloadUrl = otaUrl.replace("/ota/", "/otaMag/download/") + uuid;
+            }
+        }
+
+        firmware.setVersion(ota == null ? currentVersion : ota.getVersion());
+        firmware.setUrl(downloadUrl == null ? "" : downloadUrl);
+        return firmware;
+    }
+
+    /**
+     * 比较两个版本号
+     * 
+     * @param version1 版本1
+     * @param version2 版本2
+     * @return 如果version1 > version2返回1，version1 < version2返回-1，相等返回0
+     */
+    private static int compareVersions(String version1, String version2) {
+        if (version1 == null || version2 == null) {
+            return 0;
+        }
+
+        String[] v1Parts = version1.split("\\.");
+        String[] v2Parts = version2.split("\\.");
+
+        int length = Math.max(v1Parts.length, v2Parts.length);
+        for (int i = 0; i < length; i++) {
+            int v1 = i < v1Parts.length ? Integer.parseInt(v1Parts[i]) : 0;
+            int v2 = i < v2Parts.length ? Integer.parseInt(v2Parts[i]) : 0;
+
+            if (v1 > v2) {
+                return 1;
+            } else if (v1 < v2) {
+                return -1;
+            }
+        }
+        return 0;
+    }
 }

main/manager-api/src/main/java/xiaozhi/modules/device/service/impl/OtaServiceImpl.java

@@ -0,0 +1,85 @@
+package xiaozhi.modules.device.service.impl;
+
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.stereotype.Service;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+
+import io.micrometer.common.util.StringUtils;
+import xiaozhi.common.page.PageData;
+import xiaozhi.common.service.impl.BaseServiceImpl;
+import xiaozhi.modules.device.dao.OtaDao;
+import xiaozhi.modules.device.entity.OtaEntity;
+import xiaozhi.modules.device.service.OtaService;
+
+@Service
+public class OtaServiceImpl extends BaseServiceImpl<OtaDao, OtaEntity> implements OtaService {
+
+    @Override
+    public PageData<OtaEntity> page(Map<String, Object> params) {
+        IPage<OtaEntity> page = baseDao.selectPage(
+                getPage(params, "update_date", true),
+                getWrapper(params));
+
+        return new PageData<>(page.getRecords(), page.getTotal());
+    }
+
+    private QueryWrapper<OtaEntity> getWrapper(Map<String, Object> params) {
+        String firmwareName = (String) params.get("firmwareName");
+
+        QueryWrapper<OtaEntity> wrapper = new QueryWrapper<>();
+        wrapper.like(StringUtils.isNotBlank(firmwareName), "firmware_name", firmwareName);
+
+        return wrapper;
+    }
+
+    @Override
+    public void update(OtaEntity entity) {
+        // 检查是否存在相同类型和版本的固件（排除当前记录）
+        QueryWrapper<OtaEntity> queryWrapper = new QueryWrapper<OtaEntity>()
+                .eq("type", entity.getType())
+                .eq("version", entity.getVersion())
+                .ne("id", entity.getId()); // 排除当前记录
+
+        if (baseDao.selectCount(queryWrapper) > 0) {
+            throw new RuntimeException("已存在相同类型和版本的固件，请修改后重试");
+        }
+
+        entity.setUpdateDate(new Date());
+        baseDao.updateById(entity);
+    }
+
+    @Override
+    public void delete(String[] ids) {
+        baseDao.deleteBatchIds(Arrays.asList(ids));
+    }
+
+    @Override
+    public boolean save(OtaEntity entity) {
+        QueryWrapper<OtaEntity> queryWrapper = new QueryWrapper<OtaEntity>()
+                .eq("type", entity.getType());
+        // 同类固件只保留最新的一条
+        List<OtaEntity> otaList = baseDao.selectList(queryWrapper);
+        if (otaList != null && otaList.size() > 0) {
+            OtaEntity otaBefore = otaList.getFirst();
+            entity.setId(otaBefore.getId());
+            baseDao.updateById(entity);
+            return true;
+        }
+        return baseDao.insert(entity) > 0;
+    }
+
+    @Override
+    public OtaEntity getLatestOta(String type) {
+        QueryWrapper<OtaEntity> wrapper = new QueryWrapper<>();
+        wrapper.eq("type", type)
+                .orderByDesc("update_date")
+                .last("LIMIT 1");
+        return baseDao.selectOne(wrapper);
+    }
+}

main/manager-api/src/main/java/xiaozhi/modules/device/utils/NetworkUtil.java

@@ -1,34 +0,0 @@
-package xiaozhi.modules.device.utils;
-
-import java.util.regex.Pattern;
-
-import org.apache.commons.lang3.StringUtils;
-
-/**
- * 网络工具类
- */
-public class NetworkUtil {
-    /**
-     * MAC地址正则表达式
-     */
-    private static final Pattern macPattern = Pattern.compile("^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$");
-
-    /**
-     * 判断MAC地址是否合法
-     */
-    public static boolean isMacAddressValid(String mac) {
-        if (StringUtils.isBlank(mac)) {
-            return false;
-        }
-        // 正则校验格式
-        if (!macPattern.matcher(mac).matches()) {
-            return false;
-        }
-        // 校验MAC地址是否为单播地址
-        String normalized = mac.toLowerCase();
-        String[] parts = normalized.split("[:-]");
-        int firstByte = Integer.parseInt(parts[0], 16);
-        return (firstByte & 1) == 0; // 最低位为0表示单播地址，合法
-    }
-
-}

main/manager-api/src/main/java/xiaozhi/modules/device/vo/UserShowDeviceListVO.java

@@ -0,0 +1,31 @@
+package xiaozhi.modules.device.vo;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+@Data
+@Schema(description = "用户显示设备列表VO")
+public class UserShowDeviceListVO {
+
+    @Schema(description = "app版本")
+    private String appVersion;
+
+    @Schema(description = "绑定用户名称")
+    private String bindUserName;
+
+    @Schema(description = "设备型号")
+    private String deviceType;
+
+    @Schema(description = "设备唯一标识符")
+    private String id;
+
+    @Schema(description = "mac地址")
+    private String macAddress;
+
+    @Schema(description = "开启OTA")
+    private Integer otaUpgrade;
+
+    @Schema(description = "最近对话时间")
+    private String recentChatTime;
+
+}

main/manager-api/src/main/java/xiaozhi/modules/model/controller/ModelController.java

@@ -17,13 +17,19 @@ import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.AllArgsConstructor;
 import xiaozhi.common.page.PageData;
+import xiaozhi.common.utils.ConvertUtils;
 import xiaozhi.common.utils.Result;
+import xiaozhi.modules.agent.service.AgentTemplateService;
+import xiaozhi.modules.config.service.ConfigService;
+import xiaozhi.modules.model.dto.ModelBasicInfoDTO;
 import xiaozhi.modules.model.dto.ModelConfigBodyDTO;
 import xiaozhi.modules.model.dto.ModelConfigDTO;
 import xiaozhi.modules.model.dto.ModelProviderDTO;
-import xiaozhi.modules.model.dto.ModelProviderFieldDTO;
+import xiaozhi.modules.model.dto.VoiceDTO;
+import xiaozhi.modules.model.entity.ModelConfigEntity;
 import xiaozhi.modules.model.service.ModelConfigService;
 import xiaozhi.modules.model.service.ModelProviderService;
+import xiaozhi.modules.timbre.service.TimbreService;
 
 @AllArgsConstructor
 @RestController
@@ -32,16 +38,18 @@ import xiaozhi.modules.model.service.ModelProviderService;
 public class ModelController {
 
     private final ModelProviderService modelProviderService;
-
+    private final TimbreService timbreService;
     private final ModelConfigService modelConfigService;
+    private final ConfigService configService;
+    private final AgentTemplateService agentTemplateService;
 
-    @GetMapping("/models/names")
+    @GetMapping("/names")
     @Operation(summary = "获取所有模型名称")
-    @RequiresPermissions("sys:role:superAdmin")
-    public Result<List<String>> getModelNames(@RequestParam String modelType,
+    @RequiresPermissions("sys:role:normal")
+    public Result<List<ModelBasicInfoDTO>> getModelNames(@RequestParam String modelType,
             @RequestParam(required = false) String modelName) {
-        List<String> modelNameList = modelConfigService.getModelCodeList(modelType, modelName);
-        return new Result<List<String>>().ok(modelNameList);
+        List<ModelBasicInfoDTO> modelList = modelConfigService.getModelCodeList(modelType, modelName);
+        return new Result<List<ModelBasicInfoDTO>>().ok(modelList);
     }
 
     @GetMapping("/{modelType}/provideTypes")
@@ -52,16 +60,7 @@ public class ModelController {
         return new Result<List<ModelProviderDTO>>().ok(modelProviderDTOS);
     }
 
-    @GetMapping("/{modelType}/{provideCode}/fields")
-    @Operation(summary = "获取模型供应器字段")
-    @RequiresPermissions("sys:role:superAdmin")
-    public Result<List<ModelProviderFieldDTO>> getModelProviderFields(@PathVariable String modelType,
-            @PathVariable String provideCode) {
-        List<ModelProviderFieldDTO> fieldList = modelProviderService.getFieldList(modelType, provideCode);
-        return new Result<List<ModelProviderFieldDTO>>().ok(fieldList);
-    }
-
-    @GetMapping("/models/list")
+    @GetMapping("/list")
     @Operation(summary = "获取模型配置列表")
     @RequiresPermissions("sys:role:superAdmin")
     public Result<PageData<ModelConfigDTO>> getModelConfigList(
@@ -73,17 +72,18 @@ public class ModelController {
         return new Result<PageData<ModelConfigDTO>>().ok(pageList);
     }
 
-    @PostMapping("/models/{modelType}/{provideCode}")
+    @PostMapping("/{modelType}/{provideCode}")
     @Operation(summary = "新增模型配置")
     @RequiresPermissions("sys:role:superAdmin")
     public Result<ModelConfigDTO> addModelConfig(@PathVariable String modelType,
             @PathVariable String provideCode,
             @RequestBody ModelConfigBodyDTO modelConfigBodyDTO) {
         ModelConfigDTO modelConfigDTO = modelConfigService.add(modelType, provideCode, modelConfigBodyDTO);
+        configService.getConfig(false);
         return new Result<ModelConfigDTO>().ok(modelConfigDTO);
     }
 
-    @PutMapping("/models/{modelType}/{provideCode}/{id}")
+    @PutMapping("/{modelType}/{provideCode}/{id}")
     @Operation(summary = "编辑模型配置")
     @RequiresPermissions("sys:role:superAdmin")
     public Result<ModelConfigDTO> editModelConfig(@PathVariable String modelType,
@@ -91,25 +91,67 @@ public class ModelController {
             @PathVariable String id,
             @RequestBody ModelConfigBodyDTO modelConfigBodyDTO) {
         ModelConfigDTO modelConfigDTO = modelConfigService.edit(modelType, provideCode, id, modelConfigBodyDTO);
+        configService.getConfig(false);
         return new Result<ModelConfigDTO>().ok(modelConfigDTO);
     }
 
-    @DeleteMapping("/models/{modelType}/{provideCode}/{id}")
+    @DeleteMapping("/{id}")
     @Operation(summary = "删除模型配置")
     @RequiresPermissions("sys:role:superAdmin")
-    public Result<Void> deleteModelConfig(@PathVariable String modelType, @PathVariable String provideCode,
-            @PathVariable String id) {
-        modelConfigService.delete(modelType, provideCode, id);
+    public Result<Void> deleteModelConfig(@PathVariable String id) {
+        modelConfigService.delete(id);
         return new Result<>();
     }
 
-    @GetMapping("/models/{modelId}/voices")
+    @GetMapping("/{id}")
+    @Operation(summary = "获取模型配置")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<ModelConfigDTO> getModelConfig(@PathVariable String id) {
+        ModelConfigEntity item = modelConfigService.selectById(id);
+        ModelConfigDTO modelConfigDTO = ConvertUtils.sourceToTarget(item, ModelConfigDTO.class);
+        return new Result<ModelConfigDTO>().ok(modelConfigDTO);
+    }
+
+    @PutMapping("/enable/{id}/{status}")
+    @Operation(summary = "启用/关闭模型配置")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<Void> enableModelConfig(@PathVariable String id, @PathVariable Integer status) {
+        ModelConfigEntity entity = modelConfigService.selectById(id);
+        if (entity == null) {
+            return new Result<Void>().error("模型配置不存在");
+        }
+        entity.setIsEnabled(status);
+        modelConfigService.updateById(entity);
+        return new Result<Void>();
+    }
+
+    @PutMapping("/default/{id}")
+    @Operation(summary = "设置默认模型")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<Void> setDefaultModel(@PathVariable String id) {
+        ModelConfigEntity entity = modelConfigService.selectById(id);
+        if (entity == null) {
+            return new Result<Void>().error("模型配置不存在");
+        }
+        // 将其他模型设置为非默认
+        modelConfigService.setDefaultModel(entity.getModelType(), 0);
+        entity.setIsEnabled(1);
+        entity.setIsDefault(1);
+        modelConfigService.updateById(entity);
+
+        // 更新模板表中对应的模型ID
+        agentTemplateService.updateDefaultTemplateModelId(entity.getModelType(), entity.getId());
+
+        configService.getConfig(false);
+        return new Result<Void>();
+    }
+
+    @GetMapping("/{modelId}/voices")
     @Operation(summary = "获取模型音色")
     @RequiresPermissions("sys:role:normal")
-    public Result<List<String>> getVoiceList(@PathVariable String modelId,
+    public Result<List<VoiceDTO>> getVoiceList(@PathVariable String modelId,
             @RequestParam(required = false) String voiceName) {
-
-        List<String> voiceList = modelConfigService.getVoiceList(modelId, voiceName);
-        return new Result<List<String>>().ok(voiceList);
+        List<VoiceDTO> voiceList = timbreService.getVoiceNames(modelId, voiceName);
+        return new Result<List<VoiceDTO>>().ok(voiceList);
     }
 }

main/manager-api/src/main/java/xiaozhi/modules/model/dto/ModelBasicInfoDTO.java

@@ -0,0 +1,9 @@
+package xiaozhi.modules.model.dto;
+
+import lombok.Data;
+
+@Data
+public class ModelBasicInfoDTO {
+    private String id;
+    private String modelName;
+}

main/manager-api/src/main/java/xiaozhi/modules/model/dto/ModelConfigBodyDTO.java

@@ -2,6 +2,7 @@ package xiaozhi.modules.model.dto;
 
 import java.io.Serial;
 
+import cn.hutool.json.JSONObject;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
 
@@ -28,7 +29,7 @@ public class ModelConfigBodyDTO {
     private Integer isEnabled;
 
     @Schema(description = "模型配置(JSON格式)")
-    private String configJson;
+    private JSONObject configJson;
 
     @Schema(description = "官方文档链接")
     private String docLink;

main/manager-api/src/main/java/xiaozhi/modules/model/dto/ModelConfigDTO.java

@@ -3,6 +3,7 @@ package xiaozhi.modules.model.dto;
 import java.io.Serial;
 import java.io.Serializable;
 
+import cn.hutool.json.JSONObject;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
 
@@ -32,7 +33,7 @@ public class ModelConfigDTO implements Serializable {
     private Integer isEnabled;
 
     @Schema(description = "模型配置(JSON格式)")
-    private String configJson;
+    private JSONObject configJson;
 
     @Schema(description = "官方文档链接")
     private String docLink;

main/manager-api/src/main/java/xiaozhi/modules/model/dto/ModelProviderFieldDTO.java

@@ -1,19 +0,0 @@
-package xiaozhi.modules.model.dto;
-
-import java.io.Serializable;
-
-import io.swagger.v3.oas.annotations.media.Schema;
-import lombok.Data;
-
-@Data
-@Schema(description = "模型供应器字段")
-public class ModelProviderFieldDTO implements Serializable {
-    @Schema(description = "字段名")
-    private String key;
-
-    @Schema(description = "字段标签")
-    private String label;
-
-    @Schema(description = "字段类型")
-    private String type;
-}

main/manager-api/src/main/java/xiaozhi/modules/model/dto/VoiceDTO.java

@@ -0,0 +1,22 @@
+package xiaozhi.modules.model.dto;
+
+import java.io.Serializable;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+@Schema(description = "音色信息")
+public class VoiceDTO implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    @Schema(description = "音色ID")
+    private String id;
+
+    @Schema(description = "音色名称")
+    private String name;
+}

main/manager-api/src/main/java/xiaozhi/modules/model/entity/ModelConfigEntity.java

@@ -9,11 +9,12 @@ import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
 import com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler;
 
+import cn.hutool.json.JSONObject;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
 
 @Data
-@TableName("ai_model_config")
+@TableName(value = "ai_model_config", autoResultMap = true)
 @Schema(description = "模型配置表")
 public class ModelConfigEntity {
 
@@ -38,7 +39,7 @@ public class ModelConfigEntity {
 
     @TableField(typeHandler = JacksonTypeHandler.class)
     @Schema(description = "模型配置(JSON格式)")
-    private String configJson;
+    private JSONObject configJson;
 
     @Schema(description = "官方文档链接")
     private String docLink;

main/manager-api/src/main/java/xiaozhi/modules/model/service/ModelConfigService.java

@@ -3,12 +3,15 @@ package xiaozhi.modules.model.service;
 import java.util.List;
 
 import xiaozhi.common.page.PageData;
+import xiaozhi.common.service.BaseService;
+import xiaozhi.modules.model.dto.ModelBasicInfoDTO;
 import xiaozhi.modules.model.dto.ModelConfigBodyDTO;
 import xiaozhi.modules.model.dto.ModelConfigDTO;
+import xiaozhi.modules.model.entity.ModelConfigEntity;
 
-public interface ModelConfigService {
+public interface ModelConfigService extends BaseService<ModelConfigEntity> {
 
-    List<String> getModelCodeList(String modelType, String modelName);
+    List<ModelBasicInfoDTO> getModelCodeList(String modelType, String modelName);
 
     PageData<ModelConfigDTO> getPageList(String modelType, String modelName, String page, String limit);
 
@@ -16,7 +19,30 @@ public interface ModelConfigService {
 
     ModelConfigDTO edit(String modelType, String provideCode, String id, ModelConfigBodyDTO modelConfigBodyDTO);
 
-    void delete(String modelType, String provideCode, String id);
+    void delete(String id);
 
-    List<String> getVoiceList(String modelName, String voiceName);
+    /**
+     * 根据ID获取模型名称
+     * 
+     * @param id 模型ID
+     * @return 模型名称
+     */
+    String getModelNameById(String id);
+
+    /**
+     * 根据ID获取模型配置
+     * 
+     * @param id      模型ID
+     * @param isCache 是否缓存
+     * @return 模型配置实体
+     */
+    ModelConfigEntity getModelById(String id, boolean isCache);
+
+    /**
+     * 设置默认模型
+     * 
+     * @param modelType 模型类型
+     * @param isDefault 是否默认
+     */
+    void setDefaultModel(String modelType, int isDefault);
 }

main/manager-api/src/main/java/xiaozhi/modules/model/service/ModelProviderService.java

@@ -3,7 +3,6 @@ package xiaozhi.modules.model.service;
 import java.util.List;
 
 import xiaozhi.modules.model.dto.ModelProviderDTO;
-import xiaozhi.modules.model.dto.ModelProviderFieldDTO;
 import xiaozhi.modules.model.entity.ModelProviderEntity;
 
 public interface ModelProviderService {
@@ -19,6 +18,4 @@ public interface ModelProviderService {
     void delete();
 
     List<ModelProviderDTO> getList(String modelType, String provideCode);
-
-    List<ModelProviderFieldDTO> getFieldList(String modelType, String provideCode);
 }

main/manager-api/src/main/java/xiaozhi/modules/model/service/impl/ModelConfigServiceImpl.java

@@ -3,10 +3,9 @@ package xiaozhi.modules.model.service.impl;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
 
 import org.apache.commons.lang3.StringUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Service;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
@@ -17,16 +16,20 @@ import lombok.AllArgsConstructor;
 import xiaozhi.common.constant.Constant;
 import xiaozhi.common.exception.RenException;
 import xiaozhi.common.page.PageData;
+import xiaozhi.common.redis.RedisKeys;
+import xiaozhi.common.redis.RedisUtils;
 import xiaozhi.common.service.impl.BaseServiceImpl;
 import xiaozhi.common.utils.ConvertUtils;
+import xiaozhi.modules.agent.dao.AgentDao;
+import xiaozhi.modules.agent.entity.AgentEntity;
 import xiaozhi.modules.model.dao.ModelConfigDao;
+import xiaozhi.modules.model.dto.ModelBasicInfoDTO;
 import xiaozhi.modules.model.dto.ModelConfigBodyDTO;
 import xiaozhi.modules.model.dto.ModelConfigDTO;
 import xiaozhi.modules.model.dto.ModelProviderDTO;
 import xiaozhi.modules.model.entity.ModelConfigEntity;
 import xiaozhi.modules.model.service.ModelConfigService;
 import xiaozhi.modules.model.service.ModelProviderService;
-import xiaozhi.modules.timbre.service.TimbreService;
 
 @Service
 @AllArgsConstructor
@@ -35,13 +38,18 @@ public class ModelConfigServiceImpl extends BaseServiceImpl<ModelConfigDao, Mode
 
     private final ModelConfigDao modelConfigDao;
     private final ModelProviderService modelProviderService;
-    private final TimbreService timbreService;
-
-    private static final Logger logger = LoggerFactory.getLogger(ModelConfigServiceImpl.class);
+    private final RedisUtils redisUtils;
+    private final AgentDao agentDao;
 
     @Override
-    public List<String> getModelCodeList(String modelType, String modelName) {
-        return modelConfigDao.getModelCodeList(modelType, modelName);
+    public List<ModelBasicInfoDTO> getModelCodeList(String modelType, String modelName) {
+        List<ModelConfigEntity> entities = modelConfigDao.selectList(
+                new QueryWrapper<ModelConfigEntity>()
+                        .eq("model_type", modelType)
+                        .eq("is_enabled", 1)
+                        .like(StringUtils.isNotBlank(modelName), "model_name", "%" + modelName + "%")
+                        .select("id", "model_name"));
+        return ConvertUtils.sourceToTarget(entities, ModelBasicInfoDTO.class);
     }
 
     @Override
@@ -71,6 +79,7 @@ public class ModelConfigServiceImpl extends BaseServiceImpl<ModelConfigDao, Mode
         // 再保存供应器提供的模型
         ModelConfigEntity modelConfigEntity = ConvertUtils.sourceToTarget(modelConfigBodyDTO, ModelConfigEntity.class);
         modelConfigEntity.setModelType(modelType);
+        modelConfigEntity.setIsDefault(0);
         modelConfigDao.insert(modelConfigEntity);
         return ConvertUtils.sourceToTarget(modelConfigEntity, ModelConfigDTO.class);
     }
@@ -91,25 +100,118 @@ public class ModelConfigServiceImpl extends BaseServiceImpl<ModelConfigDao, Mode
         modelConfigEntity.setId(id);
         modelConfigEntity.setModelType(modelType);
         modelConfigDao.updateById(modelConfigEntity);
+        // 清除缓存
+        redisUtils.delete(RedisKeys.getModelConfigById(modelConfigEntity.getId()));
         return ConvertUtils.sourceToTarget(modelConfigEntity, ModelConfigDTO.class);
     }
 
     @Override
-    public void delete(String modelType, String provideCode, String id) {
-        // 先验证有没有供应器
-        if (StringUtils.isBlank(modelType) || StringUtils.isBlank(provideCode)) {
-            throw new RenException("modelType和provideCode不能为空");
-        }
-        List<ModelProviderDTO> providerList = modelProviderService.getList(modelType, provideCode);
-        if (CollectionUtil.isEmpty(providerList)) {
-            throw new RenException("供应器不存在");
+    public void delete(String id) {
+        // 查看是否是默认
+        ModelConfigEntity modelConfig = modelConfigDao.selectById(id);
+        if (modelConfig != null && modelConfig.getIsDefault() == 1) {
+            throw new RenException("该模型为默认模型，请先设置其他模型为默认模型");
         }
+        // 验证是否有引用
+        checkAgentReference(id);
+        checkIntentConfigReference(id);
 
         modelConfigDao.deleteById(id);
     }
 
+    /**
+     * 检查智能体配置是否有引用
+     * 
+     * @param modelId 模型ID
+     */
+    private void checkAgentReference(String modelId) {
+        List<AgentEntity> agents = agentDao.selectList(
+                new QueryWrapper<AgentEntity>()
+                        .eq("vad_model_id", modelId)
+                        .or()
+                        .eq("asr_model_id", modelId)
+                        .or()
+                        .eq("llm_model_id", modelId)
+                        .or()
+                        .eq("tts_model_id", modelId)
+                        .or()
+                        .eq("mem_model_id", modelId)
+                        .or()
+                        .eq("intent_model_id", modelId));
+        if (!agents.isEmpty()) {
+            String agentNames = agents.stream()
+                    .map(AgentEntity::getAgentName)
+                    .collect(Collectors.joining("、"));
+            throw new RenException(String.format("该模型配置已被智能体[%s]引用，无法删除", agentNames));
+        }
+    }
+
+    /**
+     * 检查意图识别配置是否有引用
+     * 
+     * @param modelId 模型ID
+     */
+    private void checkIntentConfigReference(String modelId) {
+        ModelConfigEntity modelConfig = modelConfigDao.selectById(modelId);
+        if (modelConfig != null
+                && "LLM".equals(modelConfig.getModelType() == null ? null : modelConfig.getModelType().toUpperCase())) {
+            List<ModelConfigEntity> intentConfigs = modelConfigDao.selectList(
+                    new QueryWrapper<ModelConfigEntity>()
+                            .eq("model_type", "Intent")
+                            .like("config_json", "%" + modelId + "%"));
+            if (!intentConfigs.isEmpty()) {
+                throw new RenException("该LLM模型已被意图识别配置引用，无法删除");
+            }
+        }
+    }
+
     @Override
-    public List<String> getVoiceList(String modelId, String voiceName) {
-        return timbreService.getVoiceNames(modelId, voiceName);
+    public String getModelNameById(String id) {
+        if (StringUtils.isBlank(id)) {
+            return null;
+        }
+
+        String cachedName = (String) redisUtils.get(RedisKeys.getModelNameById(id));
+
+        if (StringUtils.isNotBlank(cachedName)) {
+            return cachedName;
+        }
+
+        ModelConfigEntity entity = modelConfigDao.selectById(id);
+        if (entity != null) {
+            String modelName = entity.getModelName();
+            if (StringUtils.isNotBlank(modelName)) {
+                redisUtils.set(RedisKeys.getModelNameById(id), modelName);
+            }
+            return modelName;
+        }
+
+        return null;
+    }
+
+    @Override
+    public ModelConfigEntity getModelById(String id, boolean isCache) {
+        if (StringUtils.isBlank(id)) {
+            return null;
+        }
+        if (isCache) {
+            ModelConfigEntity cachedConfig = (ModelConfigEntity) redisUtils.get(RedisKeys.getModelConfigById(id));
+            if (cachedConfig != null) {
+                return ConvertUtils.sourceToTarget(cachedConfig, ModelConfigEntity.class);
+            }
+        }
+        ModelConfigEntity entity = modelConfigDao.selectById(id);
+        if (entity != null) {
+            redisUtils.set(RedisKeys.getModelConfigById(id), entity);
+        }
+        return entity;
+    }
+
+    @Override
+    public void setDefaultModel(String modelType, int isDefault) {
+        ModelConfigEntity entity = new ModelConfigEntity();
+        entity.setIsDefault(isDefault);
+        modelConfigDao.update(entity, new QueryWrapper<ModelConfigEntity>()
+                .eq("model_type", modelType));
     }
 }

main/manager-api/src/main/java/xiaozhi/modules/model/service/impl/ModelProviderServiceImpl.java

@@ -10,10 +10,8 @@ import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import lombok.AllArgsConstructor;
 import xiaozhi.common.service.impl.BaseServiceImpl;
 import xiaozhi.common.utils.ConvertUtils;
-import xiaozhi.common.utils.JsonUtils;
 import xiaozhi.modules.model.dao.ModelProviderDao;
 import xiaozhi.modules.model.dto.ModelProviderDTO;
-import xiaozhi.modules.model.dto.ModelProviderFieldDTO;
 import xiaozhi.modules.model.entity.ModelProviderEntity;
 import xiaozhi.modules.model.service.ModelProviderService;
 
@@ -56,15 +54,4 @@ public class ModelProviderServiceImpl extends BaseServiceImpl<ModelProviderDao,
         List<ModelProviderEntity> providerEntities = modelProviderDao.selectList(queryWrapper);
         return ConvertUtils.sourceToTarget(providerEntities, ModelProviderDTO.class);
     }
-
-    @Override
-    public List<ModelProviderFieldDTO> getFieldList(String modelType, String providerCode) {
-        List<String> modelProviderEntities = modelProviderDao.getFieldList(modelType, providerCode);
-        if (modelProviderEntities == null || modelProviderEntities.isEmpty()) {
-            return null;
-        }
-        String fields = modelProviderEntities.getFirst();
-        List<ModelProviderFieldDTO> fieldList = JsonUtils.parseArray(fields, ModelProviderFieldDTO.class);
-        return fieldList;
-    }
 }

main/manager-api/src/main/java/xiaozhi/modules/security/config/ShiroConfig.java

@@ -18,6 +18,8 @@ import org.springframework.context.annotation.Configuration;
 import jakarta.servlet.Filter;
 import xiaozhi.modules.security.oauth2.Oauth2Filter;
 import xiaozhi.modules.security.oauth2.Oauth2Realm;
+import xiaozhi.modules.security.secret.ServerSecretFilter;
+import xiaozhi.modules.sys.service.SysParamsService;
 
 /**
  * Shiro的配置文件
@@ -46,7 +48,7 @@ public class ShiroConfig {
     }
 
     @Bean("shiroFilter")
-    public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager) {
+    public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager, SysParamsService sysParamsService) {
         ShiroFilterConfiguration config = new ShiroFilterConfiguration();
         config.setFilterOncePerRequest(true);
 
@@ -54,9 +56,11 @@ public class ShiroConfig {
         shiroFilter.setSecurityManager(securityManager);
         shiroFilter.setShiroFilterConfiguration(config);
 
-        // oauth过滤
         Map<String, Filter> filters = new HashMap<>();
+        // oauth过滤
         filters.put("oauth2", new Oauth2Filter());
+        // 服务密钥过滤
+        filters.put("server", new ServerSecretFilter(sysParamsService));
         shiroFilter.setFilters(filters);
 
         // 添加Shiro的内置过滤器
@@ -69,6 +73,7 @@ public class ShiroConfig {
          */
         Map<String, String> filterMap = new LinkedHashMap<>();
         filterMap.put("/ota/**", "anon");
+        filterMap.put("/otaMag/download/**", "anon");
         filterMap.put("/webjars/**", "anon");
         filterMap.put("/druid/**", "anon");
         filterMap.put("/v3/api-docs/**", "anon");
@@ -76,7 +81,12 @@ public class ShiroConfig {
         filterMap.put("/favicon.ico", "anon");
         filterMap.put("/user/captcha", "anon");
         filterMap.put("/user/login", "anon");
+        filterMap.put("/user/pub-config", "anon");
         filterMap.put("/user/register", "anon");
+        // 将config路径使用server服务过滤器
+        filterMap.put("/config/**", "server");
+        filterMap.put("/agent/chat-history/report", "server");
+        filterMap.put("/agent/play/**", "anon");
         filterMap.put("/**", "oauth2");
         shiroFilter.setFilterChainDefinitionMap(filterMap);
 
@@ -94,4 +104,4 @@ public class ShiroConfig {
         advisor.setSecurityManager(securityManager);
         return advisor;
     }
-}
+}

main/manager-api/src/main/java/xiaozhi/modules/security/config/WebMvcConfig.java

@@ -1,5 +1,6 @@
 package xiaozhi.modules.security.config;
 
+import java.text.SimpleDateFormat;
 import java.util.List;
 import java.util.TimeZone;
 
@@ -18,6 +19,15 @@ import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.module.SimpleModule;
 import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
+import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
+import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
+import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
+import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
+import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
+
+import xiaozhi.common.utils.DateUtils;
 
 @Configuration
 public class WebMvcConfig implements WebMvcConfigurer {
@@ -33,11 +43,15 @@ public class WebMvcConfig implements WebMvcConfigurer {
 
     @Override
     public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
+        // 特殊用途的转换器
         converters.add(new ByteArrayHttpMessageConverter());
-        converters.add(new StringHttpMessageConverter());
         converters.add(new ResourceHttpMessageConverter());
-        converters.add(new AllEncompassingFormHttpMessageConverter());
+
+        // 通用转换器
         converters.add(new StringHttpMessageConverter());
+        converters.add(new AllEncompassingFormHttpMessageConverter());
+
+        // JSON 转换器
         converters.add(jackson2HttpMessageConverter());
     }
 
@@ -49,10 +63,29 @@ public class WebMvcConfig implements WebMvcConfigurer {
         // 忽略未知属性
         mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
 
-        // 日期格式转换
-        // mapper.setDateFormat(new SimpleDateFormat(DateUtils.DATE_TIME_PATTERN));
+        // 设置时区
         mapper.setTimeZone(TimeZone.getTimeZone("GMT+8"));
 
+        // 配置Java8日期时间序列化
+        JavaTimeModule javaTimeModule = new JavaTimeModule();
+        javaTimeModule.addSerializer(java.time.LocalDateTime.class, new LocalDateTimeSerializer(
+                java.time.format.DateTimeFormatter.ofPattern(DateUtils.DATE_TIME_PATTERN)));
+        javaTimeModule.addSerializer(java.time.LocalDate.class, new LocalDateSerializer(
+                java.time.format.DateTimeFormatter.ofPattern(DateUtils.DATE_PATTERN)));
+        javaTimeModule.addSerializer(java.time.LocalTime.class,
+                new LocalTimeSerializer(java.time.format.DateTimeFormatter.ofPattern("HH:mm:ss")));
+        javaTimeModule.addDeserializer(java.time.LocalDateTime.class, new LocalDateTimeDeserializer(
+                java.time.format.DateTimeFormatter.ofPattern(DateUtils.DATE_TIME_PATTERN)));
+        javaTimeModule.addDeserializer(java.time.LocalDate.class, new LocalDateDeserializer(
+                java.time.format.DateTimeFormatter.ofPattern(DateUtils.DATE_PATTERN)));
+        javaTimeModule.addDeserializer(java.time.LocalTime.class,
+                new LocalTimeDeserializer(java.time.format.DateTimeFormatter.ofPattern("HH:mm:ss")));
+        mapper.registerModule(javaTimeModule);
+
+        // 配置java.util.Date的序列化和反序列化
+        SimpleDateFormat dateFormat = new SimpleDateFormat(DateUtils.DATE_TIME_PATTERN);
+        mapper.setDateFormat(dateFormat);
+
         // Long类型转String类型
         SimpleModule simpleModule = new SimpleModule();
         simpleModule.addSerializer(Long.class, ToStringSerializer.instance);

main/manager-api/src/main/java/xiaozhi/modules/security/controller/LoginController.java

@@ -1,6 +1,8 @@
 package xiaozhi.modules.security.controller;
 
 import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
 
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PostMapping;
@@ -13,6 +15,7 @@ import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.servlet.http.HttpServletResponse;
 import lombok.AllArgsConstructor;
+import xiaozhi.common.constant.Constant;
 import xiaozhi.common.exception.ErrorCode;
 import xiaozhi.common.exception.RenException;
 import xiaozhi.common.page.TokenDTO;
@@ -75,6 +78,9 @@ public class LoginController {
     @PostMapping("/register")
     @Operation(summary = "注册")
     public Result<Void> register(@RequestBody LoginDTO login) {
+        if (!sysUserService.getAllowUserRegister()) {
+            throw new RenException("当前不允许普通用户注册");
+        }
         // 验证是否正确输入验证码
         boolean validate = captchaService.validate(login.getCaptchaId(), login.getCaptcha());
         if (!validate) {
@@ -111,4 +117,13 @@ public class LoginController {
         sysUserTokenService.changePassword(userId, passwordDTO);
         return new Result<>();
     }
+
+    @GetMapping("/pub-config")
+    @Operation(summary = "公共配置")
+    public Result<Map<String, Object>> pubConfig() {
+        Map<String, Object> config = new HashMap<>();
+        config.put("version", Constant.VERSION);
+        config.put("allowUserRegister", sysUserService.getAllowUserRegister());
+        return new Result<Map<String, Object>>().ok(config);
+    }
 }

main/manager-api/src/main/java/xiaozhi/modules/security/secret/ServerSecretFilter.java

@@ -0,0 +1,105 @@
+package xiaozhi.modules.security.secret;
+
+import java.io.IOException;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.shiro.web.filter.authc.AuthenticatingFilter;
+import org.springframework.web.bind.annotation.RequestMethod;
+
+import jakarta.servlet.ServletRequest;
+import jakarta.servlet.ServletResponse;
+import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import xiaozhi.common.constant.Constant;
+import xiaozhi.common.exception.ErrorCode;
+import xiaozhi.common.utils.HttpContextUtils;
+import xiaozhi.common.utils.JsonUtils;
+import xiaozhi.common.utils.Result;
+import xiaozhi.modules.sys.service.SysParamsService;
+
+/**
+ * Config API 过滤器
+ */
+@Slf4j
+@RequiredArgsConstructor
+public class ServerSecretFilter extends AuthenticatingFilter {
+    private final SysParamsService sysParamsService;
+
+    @Override
+    protected ServerSecretToken createToken(ServletRequest request, ServletResponse response) {
+        // 获取请求token
+        String token = getRequestToken((HttpServletRequest) request);
+
+        if (StringUtils.isBlank(token)) {
+            log.warn("createToken:token is empty");
+            return null;
+        }
+
+        return new ServerSecretToken(token);
+    }
+
+    @Override
+    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
+        // 对OPTIONS请求放行
+        if (((HttpServletRequest) request).getMethod().equals(RequestMethod.OPTIONS.name())) {
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    protected boolean onAccessDenied(ServletRequest servletRequest, ServletResponse servletResponse) throws Exception {
+        // 获取token并校验
+        String token = getRequestToken((HttpServletRequest) servletRequest);
+        if (StringUtils.isBlank(token)) {
+            // token为空，返回401
+            this.sendUnauthorizedResponse((HttpServletResponse) servletResponse, "服务器密钥不能为空");
+            return false;
+        }
+
+        // 验证token是否匹配
+        String serverSecret = getServerSecret();
+        if (StringUtils.isBlank(serverSecret) || !serverSecret.equals(token)) {
+            // token无效，返回401
+            this.sendUnauthorizedResponse((HttpServletResponse) servletResponse, "无效的服务器密钥");
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * 发送未授权响应
+     */
+    private void sendUnauthorizedResponse(HttpServletResponse response, String message) {
+        response.setContentType("application/json;charset=utf-8");
+        response.setHeader("Access-Control-Allow-Credentials", "true");
+        response.setHeader("Access-Control-Allow-Origin", HttpContextUtils.getOrigin());
+
+        try {
+            String json = JsonUtils.toJsonString(new Result<Void>().error(ErrorCode.UNAUTHORIZED, message));
+            response.getWriter().print(json);
+        } catch (IOException e) {
+            log.error("响应输出失败", e);
+        }
+    }
+
+    /**
+     * 获取请求的token
+     */
+    private String getRequestToken(HttpServletRequest httpRequest) {
+        String token = null;
+        // 从header中获取token
+        String authorization = httpRequest.getHeader("Authorization");
+        if (StringUtils.isNotBlank(authorization) && authorization.startsWith("Bearer ")) {
+            token = authorization.replace("Bearer ", "");
+        }
+        return token;
+    }
+
+    private String getServerSecret() {
+        return sysParamsService.getValue(Constant.SERVER_SECRET, true);
+    }
+}

main/manager-api/src/main/java/xiaozhi/modules/security/secret/ServerSecretToken.java

@@ -0,0 +1,25 @@
+package xiaozhi.modules.security.secret;
+
+import org.apache.shiro.authc.AuthenticationToken;
+
+/**
+ * Config API Token
+ */
+public class ServerSecretToken implements AuthenticationToken {
+    private static final long serialVersionUID = 1L;
+    private final String token;
+
+    public ServerSecretToken(String token) {
+        this.token = token;
+    }
+
+    @Override
+    public Object getPrincipal() {
+        return token;
+    }
+
+    @Override
+    public Object getCredentials() {
+        return token;
+    }
+} 

main/manager-api/src/main/java/xiaozhi/modules/sys/controller/AdminController.java

@@ -7,6 +7,7 @@ import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
@@ -20,6 +21,9 @@ import xiaozhi.common.constant.Constant;
 import xiaozhi.common.page.PageData;
 import xiaozhi.common.utils.Result;
 import xiaozhi.common.validator.ValidatorUtils;
+import xiaozhi.modules.device.dto.DevicePageUserDTO;
+import xiaozhi.modules.device.service.DeviceService;
+import xiaozhi.modules.device.vo.UserShowDeviceListVO;
 import xiaozhi.modules.sys.dto.AdminPageUserDTO;
 import xiaozhi.modules.sys.service.SysUserService;
 import xiaozhi.modules.sys.vo.AdminPageUserVO;
@@ -37,6 +41,8 @@ import xiaozhi.modules.sys.vo.AdminPageUserVO;
 public class AdminController {
     private final SysUserService sysUserService;
 
+    private final DeviceService deviceService;
+
     @GetMapping("/users")
     @Operation(summary = "分页查找用户")
     @RequiresPermissions("sys:role:superAdmin")
@@ -51,7 +57,6 @@ public class AdminController {
         dto.setMobile((String) params.get("mobile"));
         dto.setLimit((String) params.get(Constant.LIMIT));
         dto.setPage((String) params.get(Constant.PAGE));
-
         ValidatorUtils.validateEntity(dto);
         PageData<AdminPageUserVO> page = sysUserService.page(dto);
         return new Result<PageData<AdminPageUserVO>>().ok(page);
@@ -70,10 +75,19 @@ public class AdminController {
     @Operation(summary = "用户删除")
     @RequiresPermissions("sys:role:superAdmin")
     public Result<Void> delete(@PathVariable Long id) {
-        sysUserService.delete(new Long[] { id });
+        sysUserService.deleteById(id);
         return new Result<>();
     }
 
+    @PutMapping("/users/changeStatus/{status}")
+    @Operation(summary = "批量修改用户状态")
+    @RequiresPermissions("sys:role:superAdmin")
+    @Parameter(name = "status", description = "用户状态", required = true)
+    public Result<Void> changeStatus(@PathVariable Integer status, @RequestBody String[] userIds) {
+        sysUserService.changeStatus(status, userIds);
+        return new Result<Void>();
+    }
+
     @GetMapping("/device/all")
     @Operation(summary = "分页查找设备")
     @RequiresPermissions("sys:role:superAdmin")
@@ -82,9 +96,14 @@ public class AdminController {
             @Parameter(name = Constant.PAGE, description = "当前页码，从1开始", required = true),
             @Parameter(name = Constant.LIMIT, description = "每页显示记录数", required = true),
     })
-    public Result<Void> pageDevice(
+    public Result<PageData<UserShowDeviceListVO>> pageDevice(
             @Parameter(hidden = true) @RequestParam Map<String, Object> params) {
-        // TODO 等设备功能模块写好
-        return new Result<Void>().error(600, "等设备功能模块写好");
+        DevicePageUserDTO dto = new DevicePageUserDTO();
+        dto.setKeywords((String) params.get("keywords"));
+        dto.setLimit((String) params.get(Constant.LIMIT));
+        dto.setPage((String) params.get(Constant.PAGE));
+        ValidatorUtils.validateEntity(dto);
+        PageData<UserShowDeviceListVO> page = deviceService.page(dto);
+        return new Result<PageData<UserShowDeviceListVO>>().ok(page);
     }
 }

main/manager-api/src/main/java/xiaozhi/modules/sys/controller/SysDictDataController.java

@@ -0,0 +1,105 @@
+package xiaozhi.modules.sys.controller;
+
+import java.util.List;
+import java.util.Map;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.shiro.authz.annotation.RequiresPermissions;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.Parameters;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.AllArgsConstructor;
+import xiaozhi.common.constant.Constant;
+import xiaozhi.common.page.PageData;
+import xiaozhi.common.utils.Result;
+import xiaozhi.common.validator.ValidatorUtils;
+import xiaozhi.modules.sys.dto.SysDictDataDTO;
+import xiaozhi.modules.sys.service.SysDictDataService;
+import xiaozhi.modules.sys.vo.SysDictDataItem;
+import xiaozhi.modules.sys.vo.SysDictDataVO;
+
+/**
+ * 字典数据管理
+ *
+ * @author czc
+ * @since 2025-04-30
+ */
+@AllArgsConstructor
+@RestController
+@RequestMapping("/admin/dict/data")
+@Tag(name = "字典数据管理")
+public class SysDictDataController {
+    private final SysDictDataService sysDictDataService;
+
+    @GetMapping("/page")
+    @Operation(summary = "分页查询字典数据")
+    @RequiresPermissions("sys:role:superAdmin")
+    @Parameters({ @Parameter(name = "dictTypeId", description = "字典类型ID", required = true),
+            @Parameter(name = "dictLabel", description = "数据标签"), @Parameter(name = "dictValue", description = "数据值"),
+            @Parameter(name = Constant.PAGE, description = "当前页码，从1开始", required = true),
+            @Parameter(name = Constant.LIMIT, description = "每页显示记录数", required = true) })
+    public Result<PageData<SysDictDataVO>> page(@Parameter(hidden = true) @RequestParam Map<String, Object> params) {
+        ValidatorUtils.validateEntity(params);
+        // 强制校验dictTypeId是否存在
+        if (!params.containsKey("dictTypeId") || StringUtils.isEmpty(String.valueOf(params.get("dictTypeId")))) {
+            return new Result<PageData<SysDictDataVO>>().error("dictTypeId不能为空");
+        }
+
+        PageData<SysDictDataVO> page = sysDictDataService.page(params);
+        return new Result<PageData<SysDictDataVO>>().ok(page);
+    }
+
+    @GetMapping("/{id}")
+    @Operation(summary = "获取字典数据详情")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<SysDictDataVO> get(@PathVariable("id") Long id) {
+        SysDictDataVO vo = sysDictDataService.get(id);
+        return new Result<SysDictDataVO>().ok(vo);
+    }
+
+    @PostMapping("/save")
+    @Operation(summary = "新增字典数据")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<Void> save(@RequestBody SysDictDataDTO dto) {
+        ValidatorUtils.validateEntity(dto);
+        sysDictDataService.save(dto);
+        return new Result<>();
+    }
+
+    @PutMapping("/update")
+    @Operation(summary = "修改字典数据")
+    @RequiresPermissions("sys:role:superAdmin")
+    public Result<Void> update(@RequestBody SysDictDataDTO dto) {
+        ValidatorUtils.validateEntity(dto);
+        sysDictDataService.update(dto);
+        return new Result<>();
+    }
+
+    @PostMapping("/delete")
+    @Operation(summary = "删除字典数据")
+    @RequiresPermissions("sys:role:superAdmin")
+    @Parameter(name = "ids", description = "ID数组", required = true)
+    public Result<Void> delete(@RequestBody Long[] ids) {
+        sysDictDataService.delete(ids);
+        return new Result<>();
+    }
+
+    @GetMapping("/type/{dictType}")
+    @Operation(summary = "获取字典数据列表")
+    @RequiresPermissions("sys:role:normal")
+    public Result<List<SysDictDataItem>> getDictDataByType(@PathVariable("dictType") String dictType) {
+        List<SysDictDataItem> list = sysDictDataService.getDictDataByType(dictType);
+        return new Result<List<SysDictDataItem>>().ok(list);
+    }
+
+}