refactor(connection): 合并旧逻辑新的业务逻辑代码

resolve merge conflict
feat(sharedASR): 优化ASR启动策略，支持本地模型预加载，避免连接超时。
2026-07-23 07:33:53 +08:00 · 2025-12-29 01:20:38 +08:00 · 2025-12-29 00:09:26 +08:00 · 2025-12-28 23:13:58 +08:00 · 2025-12-27 14:24:01 +08:00 · 2025-12-26 17:39:08 +08:00
193 changed files with 18212 additions and 4684 deletions
@@ -183,8 +183,8 @@ Spearheaded by Professor Siyuan Liu's Team (South China University of Technology
 #### 🚀 部署方式选择
 | 部署方式 | 特点 | 适用场景 | 部署文档 | 配置要求 | 视频教程 | 
 |---------|------|---------|---------|---------|---------|
-| **最简化安装** | 智能对话、IOT、MCP、视觉感知 | 低配置环境，数据存储在配置文件，无需数据库 | [①Docker版](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%B8%80docker%E5%8F%AA%E8%BF%90%E8%A1%8Cserver) / [②源码部署](./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)| 如果使用`FunASR`要2核4G，如果全API，要2核2G | - | 
-| **全模块安装** | 智能对话、IOT、MCP接入点、声纹识别、视觉感知、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) / [③源码部署自动更新教程](./docs/dev-ops-integration.md) | 如果使用`FunASR`要4核8G，如果全API，要2核4G| [本地源码启动视频教程](https://www.bilibili.com/video/BV1wBJhz4Ewe) | 
+| **最简化安装** | 智能对话、单智能体管理 | 低配置环境，数据存储在配置文件，无需数据库 | [①Docker版](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%B8%80docker%E5%8F%AA%E8%BF%90%E8%A1%8Cserver) / [②源码部署](./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)| 如果使用`FunASR`要2核4G，如果全API，要2核2G | - | 
+| **全模块安装** | 智能对话、多用户管理、多智能体管理、智控台界面操作 | 完整功能体验，数据存储在数据库 |[①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) / [③源码部署自动更新教程](./docs/dev-ops-integration.md) | 如果使用`FunASR`要4核8G，如果全API，要2核4G| [本地源码启动视频教程](https://www.bilibili.com/video/BV1wBJhz4Ewe) | 

 常见问题及相关教程，可参考[这个链接](./docs/FAQ.md)

@@ -211,10 +211,10 @@ Websocket接口地址: wss://2662r3426b.vicp.fun/xiaozhi/v1/

 | 模块名称 | 入门全免费设置 | 流式配置 |
 |:---:|:---:|:---:|
-| ASR(语音识别) | FunASR(本地) | 👍FunASR(本地GPU模式) |
-| LLM(大模型) | ChatGLMLLM(智谱glm-4-flash) | 👍AliLLM(qwen3-235b-a22b-instruct-2507) 或 👍DoubaoLLM(doubao-1-5-pro-32k-250115) |
-| VLLM(视觉大模型) | ChatGLMVLLM(智谱glm-4v-flash) | 👍QwenVLVLLM(千问qwen2.5-vl-3b-instructh) |
-| TTS(语音合成) | ✅LinkeraiTTS(灵犀流式) | 👍HuoshanDoubleStreamTTS(火山双流式语音合成) 或 👍AliyunStreamTTS(阿里云流式语音合成) |
+| ASR(语音识别) | FunASR(本地) | 👍XunfeiStreamASR(讯飞流式) |
+| LLM(大模型) | glm-4-flash(智谱) | 👍qwen-flash(阿里百炼) |
+| VLLM(视觉大模型) | glm-4v-flash(智谱) | 👍qwen2.5-vl-3b-instructh(阿里百炼) |
+| TTS(语音合成) | ✅LinkeraiTTS(灵犀流式) | 👍HuoshanDoubleStreamTTS(火山流式) |
 | Intent(意图识别) | function_call(函数调用) | function_call(函数调用) |
 | Memory(记忆功能) | mem_local_short(本地短期记忆） | mem_local_short（本地短期记忆） |

@@ -260,7 +260,7 @@ Websocket接口地址: wss://2662r3426b.vicp.fun/xiaozhi/v1/
 ---

 ## 产品生态 👬
-小智是一个生态，当你使用这个产品时，也可以看看其他在这个生态圈的[优秀项目](https://github.com/78/xiaozhi-esp32?tab=readme-ov-file#%E7%9B%B8%E5%85%B3%E5%BC%80%E6%BA%90%E9%A1%B9%E7%9B%AE)
+小智是一个生态，当你使用这个产品时，也可以看看其他在这个生态圈的[优秀项目](https://github.com/78/xiaozhi-esp32/blob/main/README_zh.md#%E7%9B%B8%E5%85%B3%E5%BC%80%E6%BA%90%E9%A1%B9%E7%9B%AE)

 ---

@@ -181,8 +181,8 @@ Dieses Projekt bietet zwei Bereitstellungsmethoden. Bitte wählen Sie basierend
 #### 🚀 Auswahl der Bereitstellungsmethode
 | Bereitstellungsmethode | Funktionen | Anwendungsszenarien | Deployment-Dokumente | Konfigurationsanforderungen | Video-Tutorials |
 |---------|------|---------|---------|---------|---------|
-| **Vereinfachte Installation** | Intelligenter Dialog, IOT, MCP, visuelle Wahrnehmung | Umgebungen mit geringer Konfiguration, Daten in Konfigurationsdateien gespeichert, keine Datenbank erforderlich | [①Docker-Version](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%B8%80docker%E5%8F%AA%E8%BF%90%E8%A1%8Cserver) / [②Quellcode-Deployment](./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)| 2 Kerne 4GB bei Verwendung von `FunASR`, 2 Kerne 2GB bei allen APIs | - |
-| **Vollständige Modulinstallation** | Intelligenter Dialog, IOT, MCP-Endpunkte, Stimmabdruckerkennung, visuelle Wahrnehmung, OTA, intelligente Steuerkonsole | Vollständige Funktionserfahrung, Daten in Datenbank gespeichert |[①Docker-Version](./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) / [②Quellcode-Deployment](./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) / [③Quellcode-Deployment Auto-Update-Tutorial](./docs/dev-ops-integration.md) | 4 Kerne 8GB bei Verwendung von `FunASR`, 2 Kerne 4GB bei allen APIs| [Video-Tutorial für lokalen Quellcode-Start](https://www.bilibili.com/video/BV1wBJhz4Ewe) |
+| **Vereinfachte Installation** | Intelligenter Dialog, Einzel-Agenten-Verwaltung | Umgebungen mit geringer Konfiguration, Daten in Konfigurationsdateien gespeichert, keine Datenbank erforderlich | [①Docker-Version](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%B8%80docker%E5%8F%AA%E8%BF%90%E8%A1%8Cserver) / [②Quellcode-Deployment](./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)| 2 Kerne 4GB bei Verwendung von `FunASR`, 2 Kerne 2GB bei allen APIs | - |
+| **Vollständige Modulinstallation** | Intelligenter Dialog, Mehrbenutzerverwaltung, Mehr-Agenten-Verwaltung, Intelligente Steuerkonsole-Bedienung | Vollständige Funktionserfahrung, Daten in Datenbank gespeichert |[①Docker-Version](./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) / [②Quellcode-Deployment](./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) / [③Quellcode-Deployment Auto-Update-Tutorial](./docs/dev-ops-integration.md) | 4 Kerne 8GB bei Verwendung von `FunASR`, 2 Kerne 4GB bei allen APIs| [Video-Tutorial für lokalen Quellcode-Start](https://www.bilibili.com/video/BV1wBJhz4Ewe) |

 Häufige Fragen und entsprechende Tutorials finden Sie unter [diesem Link](./docs/FAQ.md)

@@ -209,10 +209,10 @@ Websocket-Schnittstellenadresse: wss://2662r3426b.vicp.fun/xiaozhi/v1/

 | Modulname | Einstiegslevel Kostenlose Einstellungen | Streaming-Konfiguration |
 |:---:|:---:|:---:|
-| ASR (Spracherkennung) | FunASR (Lokal) | 👍FunASR (Lokaler GPU-Modus) |
-| LLM (Großes Modell) | ChatGLMLLM (Zhipu glm-4-flash) | 👍AliLLM (qwen3-235b-a22b-instruct-2507) oder 👍DoubaoLLM (doubao-1-5-pro-32k-250115) |
-| VLLM (Vision Large Model) | ChatGLMVLLM (Zhipu glm-4v-flash) | 👍QwenVLVLLM (Qwen qwen2.5-vl-3b-instructh) |
-| TTS (Sprachsynthese) | ✅LinkeraiTTS (Lingxi-Streaming) | 👍HuoshanDoubleStreamTTS (Volcano Dual-Stream-Sprachsynthese) oder 👍AliyunStreamTTS (Alibaba Cloud Streaming-Sprachsynthese) |
+| ASR (Spracherkennung) | FunASR (Lokal) | 👍XunfeiStreamASR (Xunfei-Streaming) |
+| LLM (Großes Modell) | glm-4-flash (Zhipu) | 👍qwen-flash (Alibaba Bailian) |
+| VLLM (Vision Large Model) | glm-4v-flash (Zhipu) | 👍qwen2.5-vl-3b-instructh (Alibaba Bailian) |
+| TTS (Sprachsynthese) | ✅LinkeraiTTS (Lingxi-Streaming) | 👍HuoshanDoubleStreamTTS (Volcano-Streaming) |
 | Intent (Absichtserkennung) | function_call (Funktionsaufruf) | function_call (Funktionsaufruf) |
 | Memory (Gedächtnisfunktion) | mem_local_short (Lokales Kurzzeitgedächtnis) | mem_local_short (Lokales Kurzzeitgedächtnis) |

@@ -258,7 +258,7 @@ Wenn Sie ein Softwareentwickler sind, finden Sie hier einen [Offenen Brief an En
 ---

 ## Produktökosystem 👬
-Xiaozhi ist ein Ökosystem. Wenn Sie dieses Produkt verwenden, können Sie sich auch andere [hervorragende Projekte](https://github.com/78/xiaozhi-esp32?tab=readme-ov-file#%E7%9B%B8%E5%85%B3%E5%BC%80%E6%BA%90%E9%A1%B9%E7%9B%AE) in diesem Ökosystem ansehen
+Xiaozhi ist ein Ökosystem. Wenn Sie dieses Produkt verwenden, können Sie sich auch andere [hervorragende Projekte](https://github.com/78/xiaozhi-esp32?tab=readme-ov-file#related-open-source-projects) in diesem Ökosystem ansehen

 ---

@@ -181,8 +181,8 @@ This project provides two deployment methods. Please choose based on your specif
 #### 🚀 Deployment Method Selection
 | Deployment Method | Features | Applicable Scenarios | Deployment Docs | Configuration Requirements | Video Tutorials | 
 |---------|------|---------|---------|---------|---------|
-| **Simplified Installation** | Intelligent dialogue, IOT, MCP, visual perception | Low-configuration environments, data stored in config files, no database required | [①Docker Version](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%B8%80docker%E5%8F%AA%E8%BF%90%E8%A1%8Cserver) / [②Source Code Deployment](./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)| 2 cores 4GB if using `FunASR`, 2 cores 2GB if all APIs | - | 
-| **Full Module Installation** | Intelligent dialogue, IOT, MCP endpoints, voiceprint recognition, visual perception, OTA, intelligent control console | Complete functionality experience, data stored in database |[①Docker Version](./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) / [②Source Code Deployment](./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) / [③Source Code Deployment Auto-Update Tutorial](./docs/dev-ops-integration.md) | 4 cores 8GB if using `FunASR`, 2 cores 4GB if all APIs| [Local Source Code Startup Video Tutorial](https://www.bilibili.com/video/BV1wBJhz4Ewe) | 
+| **Simplified Installation** | Intelligent dialogue, single agent management | Low-configuration environments, data stored in config files, no database required | [①Docker Version](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%B8%80docker%E5%8F%AA%E8%BF%90%E8%A1%8Cserver) / [②Source Code Deployment](./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)| 2 cores 4GB if using `FunASR`, 2 cores 2GB if all APIs | - | 
+| **Full Module Installation** | Intelligent dialogue, multi-user management, multi-agent management, intelligent console interface operation | Complete functionality experience, data stored in database |[①Docker Version](./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) / [②Source Code Deployment](./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) / [③Source Code Deployment Auto-Update Tutorial](./docs/dev-ops-integration.md) | 4 cores 8GB if using `FunASR`, 2 cores 4GB if all APIs| [Local Source Code Startup Video Tutorial](https://www.bilibili.com/video/BV1wBJhz4Ewe) | 


 > 💡 Note: Below is a test platform deployed with the latest code. You can burn and test if needed. Concurrent users: 6, data will be cleared daily.
@@ -208,10 +208,10 @@ Websocket Interface Address: wss://2662r3426b.vicp.fun/xiaozhi/v1/

 | Module Name | Entry Level Free Settings | Streaming Configuration |
 |:---:|:---:|:---:|
-| ASR(Speech Recognition) | FunASR(Local) | 👍FunASRServer or 👍DoubaoStreamASR |
-| LLM(Large Model) | ChatGLMLLM(Zhipu glm-4-flash) | 👍DoubaoLLM(Volcano doubao-1-5-pro-32k-250115) |
-| VLLM(Vision Large Model) | ChatGLMVLLM(Zhipu glm-4v-flash) | 👍QwenVLVLLM(Qwen qwen2.5-vl-3b-instructh) |
-| TTS(Speech Synthesis) | ✅LinkeraiTTS(Lingxi streaming) | 👍HuoshanDoubleStreamTTS(Volcano dual-stream speech synthesis) |
+| ASR(Speech Recognition) | FunASR(Local) | 👍XunfeiStreamASR(Xunfei Streaming) |
+| LLM(Large Model) | glm-4-flash(Zhipu) | 👍qwen-flash(Alibaba Bailian) |
+| VLLM(Vision Large Model) | glm-4v-flash(Zhipu) | 👍qwen2.5-vl-3b-instructh(Alibaba Bailian) |
+| TTS(Speech Synthesis) | ✅LinkeraiTTS(Lingxi streaming) | 👍HuoshanDoubleStreamTTS(Volcano Streaming) |
 | Intent(Intent Recognition) | function_call(Function calling) | function_call(Function calling) |
 | Memory(Memory function) | mem_local_short(Local short-term memory) | mem_local_short(Local short-term memory) |

@@ -256,7 +256,7 @@ If you are a software developer, here is an [Open Letter to Developers](docs/con
 ---

 ## Product Ecosystem 👬
-Xiaozhi is an ecosystem. When using this product, you can also check out other [excellent projects](https://github.com/78/xiaozhi-esp32?tab=readme-ov-file#%E7%9B%B8%E5%85%B3%E5%BC%80%E6%BA%90%E9%A1%B9%E7%9B%AE) in this ecosystem
+Xiaozhi is an ecosystem. When using this product, you can also check out other [excellent projects](https://github.com/78/xiaozhi-esp32?tab=readme-ov-file#related-open-source-projects) in this ecosystem

 | Project Name | Project Address | Project Description |
 |:---------------------|:--------|:--------|
@@ -182,8 +182,8 @@ Dự án này cung cấp hai phương pháp triển khai, vui lòng chọn theo
 #### 🚀 Lựa chọn phương pháp triển khai
 | Phương pháp triển khai | Đặc điểm | Tình huống áp dụng | Tài liệu triển khai | Yêu cầu cấu hình | Video hướng dẫn |
 |---------|------|---------|---------|---------|---------|
-| **Cài đặt tối giản** | Đối thoại thông minh, IOT, MCP, cảm nhận thị giác | Môi trường cấu hình thấp, dữ liệu lưu trong tệp cấu hình, không cần cơ sở dữ liệu | [①Phiên bản Docker](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%B8%80docker%E5%8F%AA%E8%BF%90%E8%A1%8Cserver) / [②Triển khai mã nguồn](./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)| 2 nhân 4GB nếu dùng `FunASR`, 2 nhân 2GB nếu toàn API | - |
-| **Cài đặt toàn bộ module** | Đối thoại thông minh, IOT, điểm truy cập MCP, nhận dạng giọng nói, cảm nhận thị giác, OTA, bảng điều khiển thông minh | Trải nghiệm đầy đủ tính năng, dữ liệu lưu trong cơ sở dữ liệu |[①Phiên bản 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) / [②Triển khai mã nguồn](./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) / [③Hướng dẫn tự động cập nhật triển khai mã nguồn](./docs/dev-ops-integration.md) | 4 nhân 8GB nếu dùng `FunASR`, 2 nhân 4GB nếu toàn API| [Video hướng dẫn khởi động mã nguồn cục bộ](https://www.bilibili.com/video/BV1wBJhz4Ewe) |
+| **Cài đặt tối giản** | Đối thoại thông minh, quản lý đơn tác nhân | Môi trường cấu hình thấp, dữ liệu lưu trong tệp cấu hình, không cần cơ sở dữ liệu | [①Phiên bản Docker](./docs/Deployment.md#%E6%96%B9%E5%BC%8F%E4%B8%80docker%E5%8F%AA%E8%BF%90%E8%A1%8Cserver) / [②Triển khai mã nguồn](./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)| 2 nhân 4GB nếu dùng `FunASR`, 2 nhân 2GB nếu toàn API | - |
+| **Cài đặt toàn bộ module** | Đối thoại thông minh, quản lý đa người dùng, quản lý đa tác nhân, bảng điều khiển thông minh | Trải nghiệm đầy đủ tính năng, dữ liệu lưu trong cơ sở dữ liệu |[①Phiên bản 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) / [②Triển khai mã nguồn](./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) / [③Hướng dẫn tự động cập nhật triển khai mã nguồn](./docs/dev-ops-integration.md) | 4 nhân 8GB nếu dùng `FunASR`, 2 nhân 4GB nếu toàn API| [Video hướng dẫn khởi động mã nguồn cục bộ](https://www.bilibili.com/video/BV1wBJhz4Ewe) |

 Câu hỏi thường gặp và hướng dẫn liên quan, vui lòng tham khảo [liên kết này](./docs/FAQ.md)

@@ -210,10 +210,10 @@ Công cụ kiểm tra dịch vụ: https://2662r3426b.vicp.fun/test/

 | Tên module | Cài đặt miễn phí cho người mới | Cấu hình streaming |
 |:---:|:---:|:---:|
-| ASR(Nhận dạng giọng nói) | FunASR(Local) | 👍FunASR(Chế độ GPU cục bộ) |
-| LLM(Mô hình lớn) | ChatGLMLLM(Zhipu glm-4-flash) | 👍AliLLM(qwen3-235b-a22b-instruct-2507) hoặc 👍DoubaoLLM(doubao-1-5-pro-32k-250115) |
-| VLLM(Mô hình lớn thị giác) | ChatGLMVLLM(Zhipu glm-4v-flash) | 👍QwenVLVLLM(Qwen qwen2.5-vl-3b-instructh) |
-| TTS(Tổng hợp giọng nói) | ✅LinkeraiTTS(Lingxi streaming) | 👍HuoshanDoubleStreamTTS(Tổng hợp giọng nói streaming kép Volcano) hoặc 👍AliyunStreamTTS(Tổng hợp giọng nói streaming Alibaba Cloud) |
+| ASR(Nhận dạng giọng nói) | FunASR(Local) | 👍XunfeiStreamASR(Xunfei Streaming) |
+| LLM(Mô hình lớn) | glm-4-flash(Zhipu) | 👍qwen-flash(Alibaba Bailian) |
+| VLLM(Mô hình lớn thị giác) | glm-4v-flash(Zhipu) | 👍qwen2.5-vl-3b-instructh(Alibaba Bailian) |
+| TTS(Tổng hợp giọng nói) | ✅LinkeraiTTS(Lingxi streaming) | 👍HuoshanDoubleStreamTTS(Volcano Streaming) |
 | Intent(Nhận dạng ý định) | function_call(Gọi hàm) | function_call(Gọi hàm) |
 | Memory(Chức năng bộ nhớ) | mem_local_short(Bộ nhớ ngắn hạn cục bộ) | mem_local_short(Bộ nhớ ngắn hạn cục bộ) |

@@ -259,7 +259,7 @@ Nếu bạn là một nhà phát triển phần mềm, đây có một [Lá thư
 ---

 ## Hệ sinh thái sản phẩm 👬
-Xiaozhi là một hệ sinh thái, khi bạn sử dụng sản phẩm này, bạn cũng có thể xem các [dự án xuất sắc](https://github.com/78/xiaozhi-esp32?tab=readme-ov-file#%E7%9B%B8%E5%85%B3%E5%BC%80%E6%BA%90%E9%A1%B9%E7%9B%AE) khác trong hệ sinh thái này
+Xiaozhi là một hệ sinh thái, khi bạn sử dụng sản phẩm này, bạn cũng có thể xem các [dự án xuất sắc](https://github.com/78/xiaozhi-esp32?tab=readme-ov-file#related-open-source-projects) khác trong hệ sinh thái này

 ---

@@ -38,10 +38,10 @@ conda install conda-forge::ffmpeg

 | 模块名称 | 入门全免费设置 | 流式配置 |
 |:---:|:---:|:---:|
-| ASR(语音识别) | FunASR(本地) | 👍FunASR(本地GPU模式) |
-| LLM(大模型) | ChatGLMLLM(智谱glm-4-flash) | 👍AliLLM(qwen3-235b-a22b-instruct-2507) 或 👍DoubaoLLM(doubao-1-5-pro-32k-250115) |
-| VLLM(视觉大模型) | ChatGLMVLLM(智谱glm-4v-flash) | 👍QwenVLVLLM(千问qwen2.5-vl-3b-instructh) |
-| TTS(语音合成) | ✅LinkeraiTTS(灵犀流式) | 👍HuoshanDoubleStreamTTS(火山双流式语音合成) 或 👍AliyunStreamTTS(阿里云流式语音合成) |
+| ASR(语音识别) | FunASR(本地) | 👍XunfeiStreamASR(讯飞流式) |
+| LLM(大模型) | glm-4-flash(智谱) | 👍qwen-flash(阿里百炼) |
+| VLLM(视觉大模型) | glm-4v-flash(智谱) | 👍qwen2.5-vl-3b-instructh(阿里百炼) |
+| TTS(语音合成) | ✅LinkeraiTTS(灵犀流式) | 👍HuoshanDoubleStreamTTS(火山流式) |
 | Intent(意图识别) | function_call(函数调用) | function_call(函数调用) |
 | Memory(记忆功能) | mem_local_short(本地短期记忆） | mem_local_short（本地短期记忆） |

@@ -69,6 +69,7 @@ VAD:
 ### 9、编译固件相关教程
 1、[如何自己编译小智固件](./firmware-build.md)<br/>
 2、[如何基于虾哥编译好的固件修改OTA地址](./firmware-setting.md)<br/>
+3、[单模块部署如何配置固件OTA自动升级](./ota-upgrade-guide.md)<br/>

 ### 10、拓展相关教程
 1、[如何开启手机号码注册智控台](./ali-sms-integration.md)<br/>
@@ -80,6 +81,7 @@ VAD:
 7、[如何开启声纹识别](./voiceprint-integration.md)<br/>
 8、[新闻插件源配置指南](./newsnow_plugin_config.md)<br/>
 9、[知识库ragflow集成指南](./ragflow-integration.md)<br/>
+10、[如何部署上下文源](./context-provider-integration.md)<br/>

 ### 11、语音克隆、本地语音部署相关教程
 1、[如何在智控台克隆音色](./huoshan-streamTTS-voice-cloning.md)<br/>
@@ -0,0 +1,224 @@
+# 上下文源使用教程
+
+## 概述
+
+`上下文源`，就是为小智系统提示词的上下文添加【数据源】。
+
+`上下文源` 在小智在唤醒那一刻，获取外部系统的数据，并将其动态注入到大模型的系统提示词（System Prompt）中。
+让其做到唤醒时感知世界某个事物的状态。
+
+它和MCP、记忆有本质的区别：`上下文源`是强制让小智感知世界的数据；`记忆(Mem)`是让他知道之前聊了什么内容；`MCP(functionc all)`是当需要调用某项能力/知识的时候使用调用。
+
+通过这个功能，在小智唤醒的一刹那，“感知”到：
+- 人体健康传感器状态（体温、血压、血氧状态等）
+- 业务系统的实时数据（服务器负载、待办数据、股票信息等）
+- 任何可以通过 HTTP API 获取的文本信息
+
+**注意**：该功能只是方便小智在唤醒的时候感知事物的状态，而如果想要小智唤醒后实时获取事物的状态，建议在此功能上再结合MCP工具的调用。
+
+## 工作原理
+
+1. **配置源**：用户配置一个或多个 HTTP API 地址。
+2. **触发请求**：当系统构建 Prompt 时，如果发现模板中包含 `{{ dynamic_context }}` 占位符，会请求所有配置的 API。
+3. **自动注入**：系统会自动将 API 返回的数据格式化为 Markdown 列表，替换 `{{ dynamic_context }}` 占位符。
+
+## 接口规范
+
+为了让小智正确解析数据，您的 API 需要满足以下规范：
+
+- **请求方式**：`GET`
+- **请求头**：系统会自动添加 `device-id` 字段到 Request Header。
+- **响应格式**：必须返回 JSON 格式，且包含 `code` 和 `data` 字段。
+
+### 响应示例
+
+**情况 1：返回键值对**
+```json
+{
+  "code": 0,
+  "msg": "success",
+  "data": {
+    "客厅温度": "26℃",
+    "客厅湿度": "45%",
+    "大门状态": "已关闭"
+  }
+}
+```
+*注入效果：*
+```markdown
+<context>
+- **客厅温度：** 26℃
+- **客厅湿度：** 45%
+- **大门状态：** 已关闭
+</context>
+```
+
+**情况 2：返回列表**
+```json
+{
+  "code": 0,
+  "data": [
+    "您有10个待办事项",
+    "当前汽车的行驶速度是100km每小时"
+  ]
+}
+```
+*注入效果：*
+```markdown
+<context>
+- 您有10个待办事项
+- 当前汽车的行驶速度是100km每小时
+</context>
+```
+
+## 配置指南
+
+### 方式 1：智控台配置（全模块部署）
+
+1. 登录智控台，进入**角色配置**页面。
+2. 找到**上下文源**配置项（点击“编辑源”按钮）。
+3. 点击**添加**，输入您的 API 地址。
+4. 如果 API 需要鉴权，可以在**请求头**部分添加 `Authorization` 或其他 Header。
+5. 保存配置。
+
+### 方式 2：配置文件配置（单模块部署）
+
+编辑 `xiaozhi-server/data/.config.yaml` 文件，添加 `context_providers` 配置段：
+
+```yaml
+# 上下文源配置
+context_providers:
+  - url: "http://api.example.com/data"
+    headers:
+      Authorization: "Bearer your-token"
+  - url: "http://another-api.com/data"
+```
+
+## 启用功能
+
+默认情况下，系统的提示词模板文件（`data/.agent-base-prompt.txt`）中已经预置了 `{{ dynamic_context }}` 占位符，您无需手动添加。
+
+**示例：**
+
+```markdown
+<context>
+【重要！以下信息已实时提供，无需调用工具查询，请直接使用：】
+- **设备ID：** {{device_id}}
+- **当前时间：** {{current_time}}
+...
+{{ dynamic_context }}
+</context>
+```
+
+**注意**：如果您不需要使用此功能，可以选择**不配置任何上下文源**，也可以从提示词模板文件中**删除** `{{ dynamic_context }}` 占位符。
+
+## 附录：Mock 测试服务示例
+
+为了方便您测试和开发，我们提供了一个简单的 Python Mock Server 脚本。您可以运行此脚本在本地模拟 API 接口。
+
+**mock_api_server.py**
+
+```python
+import http.server
+import socketserver
+import json
+from urllib.parse import urlparse, parse_qs
+
+# 设置端口号
+PORT = 8081
+
+class MockRequestHandler(http.server.SimpleHTTPRequestHandler):
+    def do_GET(self):
+        # 解析路径和参数
+        parsed_path = urlparse(self.path)
+        path = parsed_path.path
+        query = parse_qs(parsed_path.query)
+
+        response_data = {}
+        status_code = 200
+
+        print(f"收到请求: {path}, 参数: {query}")
+
+        # Case 1: 模拟健康数据 (返回字典 Dict)
+        # 路径参数风格: /health
+        # device_id 从 Header 获取
+        if path == "/health":
+            device_id = self.headers.get("device-id", "unknown_device")
+            print(f"device_id: {device_id}")
+            response_data = {
+                "code": 0,
+                "msg": "success",
+                "data": {
+                    "测试设备ID": device_id,
+                    "心率": "80 bpm",
+                    "血压": "120/80 mmHg",
+                    "状态": "良好"
+                }
+            }
+
+        # Case 2: 模拟新闻列表 (返回列表 List)
+        # 无参数: /news/list
+        elif path == "/news/list":
+            response_data = {
+                "code": 0,
+                "msg": "success",
+                "data": [
+                    "今日头条：Python 3.14 发布",
+                    "科技新闻：AI 助手改变生活",
+                    "本地新闻：明日有大雨，记得带伞"
+                ]
+            }
+
+        # Case 3: 模拟天气简报 (返回字符串 String)
+        # 无参数: /weather/simple
+        elif path == "/weather/simple":
+            response_data = {
+                "code": 0,
+                "msg": "success",
+                "data": "今日晴转多云，气温 20-25 度，空气质量优，适合出行。"
+            }
+
+        # Case 4: 模拟设备详情 (Query参数风格)
+        # 参数风格: /device/info
+        # device_id 从 Header 获取
+        elif path == "/device/info":
+            device_id = self.headers.get("device-id", "unknown_device")
+            response_data = {
+                "code": 0,
+                "msg": "success",
+                "data": {
+                    "查询方式": "Header参数",
+                    "设备ID": device_id,
+                    "电量": "85%",
+                    "固件": "v2.0.1"
+                }
+            }
+        
+        # Case 5: 404 Not Found
+        else:
+            status_code = 404
+            response_data = {"error": "接口不存在"}
+
+        # 发送响应
+        self.send_response(status_code)
+        self.send_header('Content-type', 'application/json; charset=utf-8')
+        self.end_headers()
+        self.wfile.write(json.dumps(response_data, ensure_ascii=False).encode('utf-8'))
+
+# 启动服务
+# 允许地址重用，防止快速重启报错
+socketserver.TCPServer.allow_reuse_address = True
+with socketserver.TCPServer(("", PORT), MockRequestHandler) as httpd:
+    print(f"==================================================")
+    print(f"Mock API Server 已启动: http://localhost:{PORT}")
+    print(f"可用接口列表:")
+    print(f"1. [字典] http://localhost:{PORT}/health")
+    print(f"2. [列表] http://localhost:{PORT}/news/list")
+    print(f"3. [文本] http://localhost:{PORT}/weather/simple")
+    print(f"4. [参数] http://localhost:{PORT}/device/info")
+    print(f"==================================================")
+    try:
+        httpd.serve_forever()
+    except KeyboardInterrupt:
+        print("\n服务已停止")
+```
@@ -23,6 +23,8 @@

 ### 2.将音色资源ID分配给系统账号

+使用超级管理员账号登录智控台，点击顶部`参数字典`，在下拉菜单中，点击`系统功能配置`页面。在页面上勾选`音色克隆`，点击保存配置。即可在顶部菜单看到`音色克隆`按钮。
+
 使用超级管理员账号登录智控台，点击顶部【音色克隆】、【音色资源】。

 点击新增按钮，在【平台名称】选择“火山双流式语音合成”；
@@ -71,6 +71,7 @@ docker logs -f mcp-endpoint-server
 请你保留好上面两个`接口地址`，下一步要用到。

 # 2、全模块部署时，怎么配置MCP接入点
+首先，你要开启MCP接入点功能。在智控台，点击顶部`参数字典`，在下拉菜单中，点击`系统功能配置`页面。在页面上勾选`MCP接入点`，点击`保存配置`。在`角色配置`页面，点击`编辑功能`按钮，即可看到`mcp接入点`功能。

 如果你是全模块部署，使用管理员账号，登录智控台，点击顶部`参数字典`，选择`参数管理`功能。

@@ -76,6 +76,7 @@ MQTT_PORT=1883            # MQTT服务器端口
 UDP_PORT=8884             # UDP服务器端口
 API_PORT=8007             # 管理API端口
 MQTT_SIGNATURE_KEY=test   # MQTT签名密钥
+SERVER_SECRET=Te1st12134  # 服务器密钥，请保持和智控台（server.secret）一致或者和xiaozhi-server里（server.auth_key）保持一致
 ```
 请注意`PUBLIC_IP`配置，确保其与实际公网IP一致，如果有域名就填域名。

@@ -85,6 +86,13 @@ MQTT_SIGNATURE_KEY=test   # MQTT签名密钥
 - 注意不要用简单的密码，比如`123456`、`test`等。
 - 注意不要用简单的密码，比如`123456`、`test`等。

+`SERVER_SECRET` 是用生成websocket连接的认证信息。
+
+1、如果你是全模块部署，且你的智控台的参数管理里`server.auth.enabled`设置成了`true`，那么，`SERVER_SECRET`需要和智控台（`server.secret`）保持一致。
+
+2、如果你是单模块部署，且你在配置文件里把`server.auth.enabled`设置成了`true`，那么，`SERVER_SECRET`需要和配置文件里（`server.auth_key`）保持一致。
+
+
 6. 启动MQTT网关
 ```
 # 启动服务
@@ -0,0 +1,142 @@
+# 单模块部署固件OTA自动升级配置指南
+
+本教程将指导你如何在**单模块部署**场景下配置固件OTA自动升级功能，实现设备固件的自动更新。
+
+如果你已经使用**全模块部署**，请忽略本教程。
+
+## 功能介绍
+
+在单模块部署中，xiaozhi-server内置了OTA固件管理功能，可以自动检测设备版本并下发升级固件。系统会根据设备型号和当前版本，自动匹配并推送最新的固件版本。
+
+## 前提条件
+
+- 你已经成功进行**单模块部署**并运行xiaozhi-server
+- 设备能够正常连接到服务器
+
+## 第一步 准备固件文件
+
+### 1. 创建固件存放目录
+
+固件文件需要放在`data/bin/`目录下。如果该目录不存在，请手动创建：
+
+```bash
+mkdir -p data/bin
+```
+
+### 2. 固件文件命名规则
+
+固件文件必须遵循以下命名格式：
+
+```
+{设备型号}_{版本号}.bin
+```
+
+**命名规则说明：**
+- `设备型号`：设备的型号名称，例如 `lichuang-dev`、`bread-compact-wifi` 等
+- `版本号`：固件版本号，必须以数字开头，支持数字、字母、点号、下划线和短横线，例如 `1.6.6`、`2.0.0` 等
+- 文件扩展名必须是 `.bin`
+
+**命名示例：**
+```
+bread-compact-wifi_1.6.6.bin
+lichuang-dev_2.0.0.bin
+```
+
+### 3. 放置固件文件
+
+将准备好的固件文件（.bin文件）复制到`data/bin/`目录下：
+
+重要的事情说三遍：升级的bin文件是`xiaozhi.bin`，不是全量固件文件`merged-binary.bin`!
+
+重要的事情说三遍：升级的bin文件是`xiaozhi.bin`，不是全量固件文件`merged-binary.bin`!
+
+重要的事情说三遍：升级的bin文件是`xiaozhi.bin`，不是全量固件文件`merged-binary.bin`!
+
+```bash
+cp xiaozhi.bin data/bin/设备型号_版本号.bin
+```
+
+例如：
+```bash
+cp xiaozhi.bin data/bin/bread-compact-wifi_1.6.6.bin
+```
+
+## 第二步 配置公网访问地址（仅公网部署需要）
+
+**注意：此步骤仅适用于单模块公网部署的场景。**
+
+如果你的xiaozhi-server是公网部署（使用公网IP或域名），**必须**配置`server.vision_explain`参数，因为OTA固件下载地址会使用该配置的域名和端口。
+
+如果你是局域网部署，可以跳过此步骤。
+
+### 为什么要配置这个参数？
+
+在单模块部署中，系统生成固件下载地址时，会使用`vision_explain`配置的域名和端口作为基础地址。如果不配置或配置错误，设备将无法访问固件下载地址。
+
+### 配置方法
+
+打开`data/.config.yaml`文件，找到`server`配置段，设置`vision_explain`参数：
+
+```yaml
+server:
+  vision_explain: http://你的域名或IP:端口号/mcp/vision/explain
+```
+
+**配置示例：**
+
+局域网部署（默认）：
+```yaml
+server:
+  vision_explain: http://192.168.1.100:8003/mcp/vision/explain
+```
+
+公网域名部署：
+```yaml
+server:
+  vision_explain: http://yourdomain.com:8003/mcp/vision/explain
+```
+
+### 注意事项
+
+- 域名或IP必须是设备能够访问的地址
+- 如果使用Docker部署，不能使用Docker内部地址（如127.0.0.1或localhost）
+- 如果你使用了nginx反向代理，请填写对外的地址和端口号，不是本项目运行的端口号
+
+
+## 常见问题
+
+### 1. 设备收不到固件更新
+
+**可能原因和解决方法：**
+
+- 检查固件文件命名是否符合规则：`{型号}_{版本号}.bin`
+- 检查固件文件是否正确放置在`data/bin/`目录
+- 检查设备型号是否与固件文件名中的型号匹配
+- 检查固件版本号是否高于设备当前版本
+- 查看服务器日志，确认OTA请求是否正常处理
+
+### 2. 设备报告下载地址无法访问
+
+**可能原因和解决方法：**
+
+- 检查`server.vision_explain`配置的域名或IP是否正确
+- 确认端口号配置正确（默认8003）
+- 如果是公网部署，确保设备能够访问该公网地址
+- 如果是Docker部署，确保不是使用了内部地址（127.0.0.1）
+- 检查防火墙是否开放了对应端口
+- 如果你使用了nginx反向代理，请填写对外的地址和端口号，不是本项目运行的端口号
+
+### 3. 如何确认设备当前版本
+
+查看OTA请求日志，日志中会显示设备上报的版本号：
+
+```
+[ota_handler] - 设备 AA:BB:CC:DD:EE:FF 固件已是最新: 1.6.6
+```
+
+### 4. 固件文件放置后没有生效
+
+系统有30秒的缓存时间（默认），可以：
+- 等待30秒后再让设备发起OTA请求
+- 重启xiaozhi-server服务
+- 调整`firmware_cache_ttl`配置为更短的时间
@@ -156,6 +156,14 @@ services:

 编辑`ragflow/docker`文件夹下的`.env`文件,找到以下配置，逐个搜索，逐个修改！逐个搜索，逐个修改！

+下面对于`.env`文件的修改，60%的人会忽略`MYSQL_USER`配置导致ragflow启动不成功，因此，需要强调三次：
+
+强调第一次：如果你的`.env`文件如果没有`MYSQL_USER`配置，请在配置文件增加这项！
+
+强调第二次：如果你的`.env`文件如果没有`MYSQL_USER`配置，请在配置文件增加这项！
+
+强调第三次：如果你的`.env`文件如果没有`MYSQL_USER`配置，请在配置文件增加这项！
+
 ``` env
 # 端口设置
 SVR_WEB_HTTP_PORT=8008           # HTTP端口
@@ -230,9 +238,11 @@ docker-compose -f docker-compose.yml up -d
 在弹框中，点击"Create new Key"按钮，生成一个API Key。复制这个`API Key`，你稍后会用到。

 # 第二步 配置到智控台
-确保你的智控台版本是`0.8.7`或以上。使用超级管理员账号登录到智控台。在顶部导航栏中，点击`模型配置`，在左侧导航栏中，点击`知识库`。
+确保你的智控台版本是`0.8.7`或以上。使用超级管理员账号登录到智控台。

-在列表中找到`RAG_RAGFlow`，点击`编辑`按钮。
+首先，你要先开启知识库功能。在顶部导航栏中，点击`参数字典`，在下拉菜单中，点击`系统功能配置`页面。在页面上勾选`知识库`，点击`保存配置`。即可在导航栏看到`知识库`功能。
+
+在顶部导航栏中，点击`模型配置`，在左侧导航栏中，点击`知识库`。在列表中找到`RAG_RAGFlow`，点击`编辑`按钮。

 在`服务地址`中，填写`http://你的ragflow服务的局域网IP:8008`，例如我的ragflow服务的局域网IP是`192.168.1.100`，那么我就填写`http://192.168.1.100:8008`。

@@ -164,6 +164,8 @@ http://192.168.1.25:8005/voiceprint/health?key=abcd
 # 2、全模块部署时，怎么配置声纹识别

 ## 第一步 配置接口
+首先，你要开启声纹识别功能。在智控台，点击顶部`参数字典`，在下拉菜单中，点击`系统功能配置`页面。在页面上勾选`声纹识别`，点击`保存配置`。即可在新建智能体的卡片上看到`声纹识别`按钮。
+
 如果你是全模块部署，使用管理员账号，登录智控台，点击顶部`参数字典`，选择`参数管理`功能。

 然后搜索参数`server.voice_print`，此时，它的值应该是`null`值。
@@ -141,6 +141,11 @@ public interface Constant {
     */
    String SERVER_MQTT_SECRET = "server.mqtt_signature_key";

+    /**
+     * WebSocket认证开关
+     */
+    String SERVER_AUTH_ENABLED = "server.auth.enabled";
+
    /**
     * 无记忆
     */
@@ -299,7 +304,7 @@ public interface Constant {
    /**
     * 版本号
     */
-    public static final String VERSION = "0.8.8";
+    public static final String VERSION = "0.8.10";

    /**
     * 无效固件URL
@@ -228,4 +228,16 @@ public interface ErrorCode {

    // 智能体模板相关错误码(补充)
    int AGENT_TEMPLATE_NOT_FOUND = 10183; // 默认智能体未找到
+
+    // 知识库适配器相关错误码
+    int RAG_ADAPTER_TYPE_NOT_SUPPORTED = 10184; // 不支持的适配器类型
+    int RAG_CONFIG_VALIDATION_FAILED = 10185; // RAG配置验证失败
+    int RAG_ADAPTER_CREATION_FAILED = 10186; // 适配器创建失败
+    int RAG_ADAPTER_INIT_FAILED = 10187; // 适配器初始化失败
+    int RAG_ADAPTER_CONNECTION_FAILED = 10188; // 适配器连接测试失败
+    int RAG_ADAPTER_OPERATION_FAILED = 10189; // 适配器操作失败
+    int RAG_ADAPTER_NOT_FOUND = 10190; // 适配器未找到
+    int RAG_ADAPTER_CACHE_ERROR = 10191; // 适配器缓存错误
+    int RAG_ADAPTER_TYPE_NOT_FOUND = 10192; // 适配器类型未找到
+
 }
@@ -159,4 +159,11 @@ public class RedisKeys {
    public static String getKnowledgeBaseCacheKey(String datasetId) {
        return "knowledge:base:" + datasetId;
    }
+
+    /**
+     * 获取临时注册设备标记key
+     */
+    public static String getTmpRegisterMacKey(String deviceId) {
+        return "tmp_register_mac:" + deviceId;
+    }
 }
@@ -44,6 +44,8 @@ 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.AgentChatSummaryService;
+import xiaozhi.modules.agent.service.AgentContextProviderService;
 import xiaozhi.modules.agent.service.AgentPluginMappingService;
 import xiaozhi.modules.agent.service.AgentService;
 import xiaozhi.modules.agent.service.AgentTemplateService;
@@ -64,6 +66,8 @@ public class AgentController {
    private final AgentChatHistoryService agentChatHistoryService;
    private final AgentChatAudioService agentChatAudioService;
    private final AgentPluginMappingService agentPluginMappingService;
+    private final AgentContextProviderService agentContextProviderService;
+    private final AgentChatSummaryService agentChatSummaryService;
    private final RedisUtils redisUtils;

    @GetMapping("/list")
@@ -117,6 +121,27 @@ public class AgentController {
        return new Result<>();
    }

+    @PostMapping("/chat-summary/{sessionId}/save")
+    @Operation(summary = "根据会话ID生成聊天记录总结并保存（异步执行）")
+    public Result<Void> generateAndSaveChatSummary(@PathVariable String sessionId) {
+        try {
+            // 异步执行总结生成任务，立即返回成功响应
+            new Thread(() -> {
+                try {
+                    agentChatSummaryService.generateAndSaveChatSummary(sessionId);
+                    System.out.println("异步执行会话 " + sessionId + " 的聊天记录总结完成");
+                } catch (Exception e) {
+                    System.err.println("异步执行会话 " + sessionId + " 的聊天记录总结失败: " + e.getMessage());
+                }
+            }).start();
+
+            // 立即返回成功响应，不等待总结生成完成
+            return new Result<Void>().ok(null);
+        } catch (Exception e) {
+            return new Result<Void>().error("启动异步总结生成任务失败: " + e.getMessage());
+        }
+    }
+
    @PutMapping("/{id}")
    @Operation(summary = "更新智能体")
    @RequiresPermissions("sys:role:normal")
@@ -135,6 +160,8 @@ public class AgentController {
        agentChatHistoryService.deleteByAgentId(id, true, true);
        // 删除关联的插件
        agentPluginMappingService.deleteByAgentId(id);
+        // 删除关联的上下文源配置
+        agentContextProviderService.deleteByAgentId(id);
        // 再删除智能体
        agentService.deleteById(id);
        return new Result<>();
@@ -182,6 +209,7 @@ public class AgentController {
        List<AgentChatHistoryDTO> result = agentChatHistoryService.getChatHistoryBySessionId(id, sessionId);
        return new Result<List<AgentChatHistoryDTO>>().ok(result);
    }
+
    @GetMapping("/{id}/chat-history/user")
    @Operation(summary = "获取智能体聊天记录（用户）")
    @RequiresPermissions("sys:role:normal")
@@ -0,0 +1,9 @@
+package xiaozhi.modules.agent.dao;
+
+import org.apache.ibatis.annotations.Mapper;
+import xiaozhi.common.dao.BaseDao;
+import xiaozhi.modules.agent.entity.AgentContextProviderEntity;
+
+@Mapper
+public interface AgentContextProviderDao extends BaseDao<AgentContextProviderEntity> {
+}
@@ -1,6 +1,9 @@
 package xiaozhi.modules.agent.dao;

+import java.util.List;
+
 import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;

 import com.baomidou.mybatisplus.core.mapper.BaseMapper;

@@ -15,12 +18,6 @@ import xiaozhi.modules.agent.entity.AgentChatHistoryEntity;
 */
@Mapper
 public interface AiAgentChatHistoryDao extends BaseMapper<AgentChatHistoryEntity> {
-    /**
-     * 根据智能体ID删除音频
-     *
-     * @param agentId 智能体ID
-     */
-    void deleteAudioByAgentId(String agentId);

    /**
     * 根据智能体ID删除聊天历史记录
@@ -35,4 +32,19 @@ public interface AiAgentChatHistoryDao extends BaseMapper<AgentChatHistoryEntity
     * @param agentId 智能体ID
     */
    void deleteAudioIdByAgentId(String agentId);
+
+    /**
+     * 根据智能体ID获取所有音频ID列表
+     *
+     * @param agentId 智能体ID
+     * @return 音频ID列表
+     */
+    List<String> getAudioIdsByAgentId(String agentId);
+
+    /**
+     * 批量删除音频
+     *
+     * @param audioIds 音频ID列表
+     */
+    void deleteAudioByIds(@Param("audioIds") List<String> audioIds);
 }
@@ -0,0 +1,45 @@
+package xiaozhi.modules.agent.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+/**
+ * 智能体聊天记录总结DTO
+ */
+@Data
+@Schema(description = "智能体聊天记录总结对象")
+public class AgentChatSummaryDTO {
+
+    @Schema(description = "会话ID")
+    private String sessionId;
+
+    @Schema(description = "智能体ID")
+    private String agentId;
+
+    @Schema(description = "总结内容")
+    private String summary;
+
+    @Schema(description = "总结状态")
+    private boolean success;
+
+    @Schema(description = "错误信息")
+    private String errorMessage;
+
+    public AgentChatSummaryDTO() {
+        this.success = true;
+    }
+
+    public AgentChatSummaryDTO(String sessionId, String agentId, String summary) {
+        this.sessionId = sessionId;
+        this.agentId = agentId;
+        this.summary = summary;
+        this.success = true;
+    }
+
+    public AgentChatSummaryDTO(String sessionId, String errorMessage) {
+        this.sessionId = sessionId;
+        this.errorMessage = errorMessage;
+        this.success = false;
+    }
+
+}
@@ -69,6 +69,9 @@ public class AgentUpdateDTO implements Serializable {
    @Schema(description = "排序", example = "1", nullable = true)
    private Integer sort;

+    @Schema(description = "上下文源配置", nullable = true)
+    private List<ContextProviderDTO> contextProviders;
+
    @Data
    @Schema(description = "插件函数信息")
    public static class FunctionInfo implements Serializable {
@@ -0,0 +1,19 @@
+package xiaozhi.modules.agent.dto;
+
+import java.io.Serializable;
+import java.util.Map;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+@Data
+@Schema(description = "上下文源配置DTO")
+public class ContextProviderDTO implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    @Schema(description = "URL地址")
+    private String url;
+
+    @Schema(description = "请求头")
+    private Map<String, Object> headers;
+}
@@ -0,0 +1,43 @@
+package xiaozhi.modules.agent.entity;
+
+import java.util.Date;
+import java.util.List;
+
+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 com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+import xiaozhi.modules.agent.dto.ContextProviderDTO;
+
+@Data
+@TableName(value = "ai_agent_context_provider", autoResultMap = true)
+@Schema(description = "智能体上下文源配置")
+public class AgentContextProviderEntity {
+
+    @TableId(type = IdType.ASSIGN_UUID)
+    @Schema(description = "主键")
+    private String id;
+
+    @Schema(description = "智能体ID")
+    private String agentId;
+
+    @Schema(description = "上下文源配置")
+    @TableField(typeHandler = JacksonTypeHandler.class)
+    private List<ContextProviderDTO> contextProviders;
+
+    @Schema(description = "创建者")
+    private Long creator;
+
+    @Schema(description = "创建时间")
+    private Date createdAt;
+
+    @Schema(description = "更新者")
+    private Long updater;
+
+    @Schema(description = "更新时间")
+    private Date updatedAt;
+}
@@ -0,0 +1,15 @@
+package xiaozhi.modules.agent.service;
+
+/**
+ * 智能体聊天记录总结服务接口
+ */
+public interface AgentChatSummaryService {
+
+    /**
+     * 根据会话ID生成聊天记录总结并保存到智能体记忆
+     * 
+     * @param sessionId 会话ID
+     * @return 保存结果
+     */
+    boolean generateAndSaveChatSummary(String sessionId);
+}
@@ -0,0 +1,25 @@
+package xiaozhi.modules.agent.service;
+
+import xiaozhi.common.service.BaseService;
+import xiaozhi.modules.agent.entity.AgentContextProviderEntity;
+
+public interface AgentContextProviderService extends BaseService<AgentContextProviderEntity> {
+    /**
+     * 根据智能体ID获取上下文源配置
+     * @param agentId 智能体ID
+     * @return 上下文源配置实体
+     */
+    AgentContextProviderEntity getByAgentId(String agentId);
+
+    /**
+     * 保存或更新上下文源配置
+     * @param entity 实体
+     */
+    void saveOrUpdateByAgentId(AgentContextProviderEntity entity);
+
+    /**
+     * 根据智能体ID删除上下文源配置
+     * @param agentId 智能体ID
+     */
+    void deleteByAgentId(String agentId);
+}
@@ -17,6 +17,7 @@ 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.AgentChatSummaryService;
 import xiaozhi.modules.agent.service.AgentService;
 import xiaozhi.modules.agent.service.biz.AgentChatHistoryBizService;
 import xiaozhi.modules.device.entity.DeviceEntity;
@@ -36,6 +37,7 @@ public class AgentChatHistoryBizServiceImpl implements AgentChatHistoryBizServic
    private final AgentService agentService;
    private final AgentChatHistoryService agentChatHistoryService;
    private final AgentChatAudioService agentChatAudioService;
+    private final AgentChatSummaryService agentChatSummaryService;
    private final RedisUtils redisUtils;
    private final DeviceService deviceService;

@@ -50,7 +52,8 @@ public class AgentChatHistoryBizServiceImpl implements AgentChatHistoryBizServic
    public Boolean report(AgentChatHistoryReportDTO report) {
        String macAddress = report.getMacAddress();
        Byte chatType = report.getChatType();
-        Long reportTimeMillis = null != report.getReportTime() ? report.getReportTime() * 1000 : System.currentTimeMillis();
+        Long reportTimeMillis = null != report.getReportTime() ? report.getReportTime() * 1000
+                : System.currentTimeMillis();
        log.info("小智设备聊天上报请求: macAddress={}, type={} reportTime={}", macAddress, chatType, reportTimeMillis);

        // 根据设备MAC地址查询对应的默认智能体，判断是否需要上报
@@ -105,7 +108,8 @@ public class AgentChatHistoryBizServiceImpl implements AgentChatHistoryBizServic
    /**
     * 组装上报数据
     */
-    private void saveChatText(AgentChatHistoryReportDTO report, String agentId, String macAddress, String audioId, Long reportTime) {
+    private void saveChatText(AgentChatHistoryReportDTO report, String agentId, String macAddress, String audioId,
+            Long reportTime) {
        // 构建聊天记录实体
        AgentChatHistoryEntity entity = AgentChatHistoryEntity.builder()
                .macAddress(macAddress)
@@ -84,7 +84,16 @@ public class AgentChatHistoryServiceImpl extends ServiceImpl<AiAgentChatHistoryD
    @Transactional(rollbackFor = Exception.class)
    public void deleteByAgentId(String agentId, Boolean deleteAudio, Boolean deleteText) {
        if (deleteAudio) {
-            baseMapper.deleteAudioByAgentId(agentId);
+            // 分批删除音频,避免超时
+            List<String> audioIds = baseMapper.getAudioIdsByAgentId(agentId);
+            if (audioIds != null && !audioIds.isEmpty()) {
+                int batchSize = 1000; // 每批删除1000条
+                for (int i = 0; i < audioIds.size(); i += batchSize) {
+                    int end = Math.min(i + batchSize, audioIds.size());
+                    List<String> batch = audioIds.subList(i, end);
+                    baseMapper.deleteAudioByIds(batch);
+                }
+            }
        }
        if (deleteAudio && !deleteText) {
            baseMapper.deleteAudioIdByAgentId(agentId);
@@ -107,7 +116,7 @@ public class AgentChatHistoryServiceImpl extends ServiceImpl<AiAgentChatHistoryD
                // 添加此行，确保查询结果按照创建时间降序排列
                // 使用id的原因：数据形式，id越大的创建时间就越晚，所以使用id的结果和创建时间降序排列结果一样
                // id作为降序排列的优势，性能高，有主键索引，不用在排序的时候重新进行排除扫描比较
-                .orderByDesc(AgentChatHistoryEntity::getId); 
+                .orderByDesc(AgentChatHistoryEntity::getId);

        // 构建分页查询，查询前50页数据
        Page<AgentChatHistoryEntity> pageParam = new Page<>(0, 50);
@@ -0,0 +1,423 @@
+package xiaozhi.modules.agent.service.impl;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+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;
+
+import lombok.RequiredArgsConstructor;
+import xiaozhi.modules.agent.dto.AgentChatHistoryDTO;
+import xiaozhi.modules.agent.dto.AgentChatSummaryDTO;
+import xiaozhi.modules.agent.dto.AgentMemoryDTO;
+import xiaozhi.modules.agent.dto.AgentUpdateDTO;
+import xiaozhi.modules.agent.entity.AgentChatHistoryEntity;
+import xiaozhi.modules.agent.service.AgentChatHistoryService;
+import xiaozhi.modules.agent.service.AgentChatSummaryService;
+import xiaozhi.modules.agent.service.AgentService;
+import xiaozhi.modules.agent.vo.AgentInfoVO;
+import xiaozhi.modules.device.entity.DeviceEntity;
+import xiaozhi.modules.device.service.DeviceService;
+import xiaozhi.modules.llm.service.LLMService;
+import xiaozhi.modules.model.entity.ModelConfigEntity;
+import xiaozhi.modules.model.service.ModelConfigService;
+
+/**
+ * 智能体聊天记录总结服务实现类
+ * 实现Python端mem_local_short.py中的总结逻辑
+ */
+@Service
+@RequiredArgsConstructor
+public class AgentChatSummaryServiceImpl implements AgentChatSummaryService {
+
+    private static final Logger log = LoggerFactory.getLogger(AgentChatSummaryServiceImpl.class);
+
+    private final AgentChatHistoryService agentChatHistoryService;
+    private final AgentService agentService;
+    private final DeviceService deviceService;
+    private final LLMService llmService;
+    private final ModelConfigService modelConfigService;
+
+    // 总结规则常量
+    private static final int MAX_SUMMARY_LENGTH = 1800; // 最大总结长度
+    private static final Pattern JSON_PATTERN = Pattern.compile("\\{.*?\\}", Pattern.DOTALL);
+    private static final Pattern DEVICE_CONTROL_PATTERN = Pattern.compile("设备控制|设备操作|控制设备|设备状态",
+            Pattern.CASE_INSENSITIVE);
+    private static final Pattern WEATHER_PATTERN = Pattern.compile("天气|温度|湿度|降雨|气象", Pattern.CASE_INSENSITIVE);
+    private static final Pattern DATE_PATTERN = Pattern.compile("日期|时间|星期|月份|年份", Pattern.CASE_INSENSITIVE);
+
+    private AgentChatSummaryDTO generateChatSummary(String sessionId) {
+        try {
+            System.out.println("开始生成会话 " + sessionId + " 的聊天记录总结");
+
+            // 1. 根据sessionId获取聊天记录
+            List<AgentChatHistoryDTO> chatHistory = getChatHistoryBySessionId(sessionId);
+            if (chatHistory == null || chatHistory.isEmpty()) {
+                return new AgentChatSummaryDTO(sessionId, "未找到该会话的聊天记录");
+            }
+
+            // 2. 获取智能体信息
+            String agentId = getAgentIdFromSession(sessionId, chatHistory);
+            if (StringUtils.isBlank(agentId)) {
+                return new AgentChatSummaryDTO(sessionId, "无法获取智能体信息");
+            }
+
+            // 3. 提取关键对话内容
+            List<String> meaningfulMessages = extractMeaningfulMessages(chatHistory);
+            if (meaningfulMessages.isEmpty()) {
+                return new AgentChatSummaryDTO(sessionId, "没有有效的对话内容可总结");
+            }
+
+            // 4. 生成总结（generateSummaryFromMessages方法已包含长度限制逻辑）
+            String summary = generateSummaryFromMessages(meaningfulMessages, agentId);
+
+            System.out.println("成功生成会话 " + sessionId + " 的聊天记录总结，长度: " + summary.length() + " 字符");
+            return new AgentChatSummaryDTO(sessionId, agentId, summary);
+
+        } catch (Exception e) {
+            System.err.println("生成会话 " + sessionId + " 的聊天记录总结时发生错误: " + e.getMessage());
+            return new AgentChatSummaryDTO(sessionId, "生成总结时发生错误: " + e.getMessage());
+        }
+    }
+
+    @Override
+    public boolean generateAndSaveChatSummary(String sessionId) {
+        try {
+            // 1. 生成总结
+            AgentChatSummaryDTO summaryDTO = generateChatSummary(sessionId);
+            if (!summaryDTO.isSuccess()) {
+                System.err.println("生成总结失败: " + summaryDTO.getErrorMessage());
+                return false;
+            }
+
+            // 2. 获取设备信息（通过会话关联的设备）
+            DeviceEntity device = getDeviceBySessionId(sessionId);
+            if (device == null) {
+                System.err.println("未找到与会话 " + sessionId + " 关联的设备");
+                return false;
+            }
+
+            // 3. 更新智能体记忆
+            AgentMemoryDTO memoryDTO = new AgentMemoryDTO();
+            memoryDTO.setSummaryMemory(summaryDTO.getSummary());
+
+            // 调用现有接口更新记忆
+            agentService.updateAgentById(device.getAgentId(),
+                    new AgentUpdateDTO() {
+                        {
+                            setSummaryMemory(summaryDTO.getSummary());
+                        }
+                    });
+
+            System.out.println("成功保存会话 " + sessionId + " 的聊天记录总结到智能体 " + device.getAgentId());
+            return true;
+
+        } catch (Exception e) {
+            System.err.println("保存会话 " + sessionId + " 的聊天记录总结时发生错误: " + e.getMessage());
+            return false;
+        }
+    }
+
+    /**
+     * 根据会话ID获取聊天记录
+     */
+    private List<AgentChatHistoryDTO> getChatHistoryBySessionId(String sessionId) {
+        try {
+            // 这里需要根据sessionId获取聊天记录
+            // 由于现有接口需要agentId，我们需要先找到关联的agentId
+            String agentId = findAgentIdBySessionId(sessionId);
+            if (StringUtils.isBlank(agentId)) {
+                return null;
+            }
+            return agentChatHistoryService.getChatHistoryBySessionId(agentId, sessionId);
+        } catch (Exception e) {
+            System.err.println("获取会话 " + sessionId + " 的聊天记录失败: " + e.getMessage());
+            return null;
+        }
+    }
+
+    /**
+     * 根据会话ID查找关联的智能体ID
+     */
+    private String findAgentIdBySessionId(String sessionId) {
+        try {
+            // 查询该会话的第一条记录获取agentId
+            QueryWrapper<AgentChatHistoryEntity> wrapper = new QueryWrapper<>();
+            wrapper.select("agent_id")
+                    .eq("session_id", sessionId)
+                    .last("LIMIT 1");
+
+            AgentChatHistoryEntity entity = agentChatHistoryService.getOne(wrapper);
+            return entity != null ? entity.getAgentId() : null;
+        } catch (Exception e) {
+            System.err.println("根据会话ID " + sessionId + " 查找智能体ID失败: " + e.getMessage());
+            return null;
+        }
+    }
+
+    /**
+     * 从会话中获取智能体ID
+     */
+    private String getAgentIdFromSession(String sessionId, List<AgentChatHistoryDTO> chatHistory) {
+        // 直接从数据库查询智能体ID
+        return findAgentIdBySessionId(sessionId);
+    }
+
+    /**
+     * 提取有意义的对话内容（只提取用户消息，排除AI回复）
+     */
+    private List<String> extractMeaningfulMessages(List<AgentChatHistoryDTO> chatHistory) {
+        List<String> meaningfulMessages = new ArrayList<>();
+
+        for (AgentChatHistoryDTO message : chatHistory) {
+            // 只处理用户消息（chatType = 1）
+            if (message.getChatType() != null && message.getChatType() == 1) {
+                String content = extractContentFromMessage(message);
+                if (isMeaningfulMessage(content)) {
+                    meaningfulMessages.add(content);
+                }
+            }
+        }
+
+        return meaningfulMessages;
+    }
+
+    /**
+     * 从消息中提取内容（处理JSON格式）
+     */
+    private String extractContentFromMessage(AgentChatHistoryDTO message) {
+        String content = message.getContent();
+        if (StringUtils.isBlank(content)) {
+            return "";
+        }
+
+        // 处理JSON格式内容（与前端ChatHistoryDialog.vue逻辑一致）
+        Matcher matcher = JSON_PATTERN.matcher(content);
+        if (matcher.find()) {
+            String jsonContent = matcher.group();
+            // 简化处理：提取JSON中的文本内容
+            return extractTextFromJson(jsonContent);
+        }
+
+        return content;
+    }
+
+    /**
+     * 从JSON中提取文本内容
+     */
+    private String extractTextFromJson(String jsonContent) {
+        // 简化处理：提取"content"字段的值
+        Pattern contentPattern = Pattern.compile("\"content\"\s*:\s*\"([^\"]*)\"");
+        Matcher matcher = contentPattern.matcher(jsonContent);
+        if (matcher.find()) {
+            return matcher.group(1);
+        }
+        return jsonContent;
+    }
+
+    /**
+     * 判断是否为有意义的消息
+     */
+    private boolean isMeaningfulMessage(String content) {
+        if (StringUtils.isBlank(content)) {
+            return false;
+        }
+
+        // 排除设备控制信息
+        if (DEVICE_CONTROL_PATTERN.matcher(content).find()) {
+            return false;
+        }
+
+        // 排除日期天气等无关内容
+        if (WEATHER_PATTERN.matcher(content).find() || DATE_PATTERN.matcher(content).find()) {
+            return false;
+        }
+
+        // 排除过短的消息
+        return content.length() >= 5;
+    }
+
+    /**
+     * 从消息生成总结
+     */
+    private String generateSummaryFromMessages(List<String> messages, String agentId) {
+        if (messages.isEmpty()) {
+            return "本次对话内容较少，没有需要总结的重要信息。";
+        }
+
+        // 构建完整的对话内容
+        StringBuilder conversation = new StringBuilder();
+        for (int i = 0; i < messages.size(); i++) {
+            conversation.append("消息").append(i + 1).append(": ").append(messages.get(i)).append("\n");
+        }
+
+        try {
+            // 获取当前智能体的历史记忆
+            String historyMemory = getCurrentAgentMemory(agentId);
+
+            // 调用LLM服务进行智能总结，传递agentId以获取正确的模型配置
+            String summary = callJavaLLMForSummaryWithHistory(conversation.toString(), historyMemory, agentId);
+
+            // 应用总结规则：限制最大长度
+            if (summary.length() > MAX_SUMMARY_LENGTH) {
+                summary = summary.substring(0, MAX_SUMMARY_LENGTH) + "...";
+            }
+
+            return summary;
+        } catch (Exception e) {
+            System.err.println("调用Java端LLM服务失败: " + e.getMessage());
+            throw new RuntimeException("LLM服务不可用，无法生成聊天总结");
+        }
+    }
+
+    /**
+     * 获取当前智能体的历史记忆
+     */
+    private String getCurrentAgentMemory(String agentId) {
+        try {
+            if (StringUtils.isBlank(agentId)) {
+                return null;
+            }
+
+            // 获取智能体信息
+            AgentInfoVO agentInfo = agentService.getAgentById(agentId);
+            if (agentInfo == null) {
+                return null;
+            }
+
+            // 返回智能体的当前总结记忆
+            return agentInfo.getSummaryMemory();
+        } catch (Exception e) {
+            System.err.println("获取智能体历史记忆失败，agentId: " + agentId + ", 错误: " + e.getMessage());
+            return null;
+        }
+    }
+
+    /**
+     * 调用Java端LLM服务进行智能总结（支持历史记忆合并）
+     */
+    private String callJavaLLMForSummaryWithHistory(String conversation, String historyMemory, String agentId) {
+        try {
+            // 获取智能体配置，从中提取记忆总结的模型ID
+            String modelId = getMemorySummaryModelId(agentId);
+
+            if (StringUtils.isBlank(modelId)) {
+                System.out.println("未找到记忆总结的LLM模型配置，使用默认LLM服务");
+                return llmService.generateSummaryWithHistory(conversation, historyMemory, null, null);
+            }
+
+            // 使用指定的模型ID调用LLM服务（支持历史记忆合并）
+            String summary = llmService.generateSummaryWithHistory(conversation, historyMemory, null, modelId);
+
+            if (StringUtils.isNotBlank(summary) && !summary.equals("服务暂不可用") && !summary.equals("总结生成失败")) {
+                return summary;
+            }
+
+            throw new RuntimeException("Java端LLM服务返回异常: " + summary);
+
+        } catch (Exception e) {
+            System.err.println("调用Java端LLM服务异常，agentId: " + agentId + ", 错误: " + e.getMessage());
+            throw e;
+        }
+    }
+
+    /**
+     * 调用Java端LLM服务进行智能总结
+     */
+    private String callJavaLLMForSummary(String conversation, String agentId) {
+        try {
+            // 获取智能体配置，从中提取记忆总结的模型ID
+            String modelId = getMemorySummaryModelId(agentId);
+
+            if (StringUtils.isBlank(modelId)) {
+                System.out.println("未找到记忆总结的LLM模型配置，使用默认LLM服务");
+                return llmService.generateSummary(conversation);
+            }
+
+            // 使用指定的模型ID调用LLM服务
+            String summary = llmService.generateSummaryWithModel(conversation, modelId);
+
+            if (StringUtils.isNotBlank(summary) && !summary.equals("服务暂不可用") && !summary.equals("总结生成失败")) {
+                return summary;
+            }
+
+            throw new RuntimeException("Java端LLM服务返回异常: " + summary);
+
+        } catch (Exception e) {
+            System.err.println("调用Java端LLM服务异常，agentId: " + agentId + ", 错误: " + e.getMessage());
+            throw e;
+        }
+    }
+
+    /**
+     * 获取记忆总结的LLM模型ID
+     */
+    private String getMemorySummaryModelId(String agentId) {
+        try {
+            if (StringUtils.isBlank(agentId)) {
+                return null;
+            }
+
+            // 获取智能体信息
+            AgentInfoVO agentInfo = agentService.getAgentById(agentId);
+            if (agentInfo == null) {
+                return null;
+            }
+
+            // 获取智能体的记忆模型ID
+            String memModelId = agentInfo.getMemModelId();
+            if (StringUtils.isBlank(memModelId)) {
+                return null;
+            }
+
+            // 获取记忆模型配置
+            ModelConfigEntity memModelConfig = modelConfigService.getModelByIdFromCache(memModelId);
+            if (memModelConfig == null || memModelConfig.getConfigJson() == null) {
+                return null;
+            }
+
+            // 从记忆模型配置中提取对应的LLM模型ID
+            Map<String, Object> configMap = memModelConfig.getConfigJson();
+            String llmModelId = (String) configMap.get("llm");
+
+            if (StringUtils.isBlank(llmModelId)) {
+                // 如果记忆模型没有配置独立的LLM，则使用智能体的默认LLM模型
+                return agentInfo.getLlmModelId();
+            }
+
+            return llmModelId;
+        } catch (Exception e) {
+            System.err.println("获取记忆总结LLM模型ID失败，agentId: " + agentId + ", 错误: " + e.getMessage());
+            return null;
+        }
+    }
+
+    /**
+     * 根据会话ID获取设备信息
+     */
+    private DeviceEntity getDeviceBySessionId(String sessionId) {
+        try {
+            // 查询该会话的第一条记录获取macAddress
+            QueryWrapper<AgentChatHistoryEntity> wrapper = new QueryWrapper<>();
+            wrapper.select("mac_address")
+                    .eq("session_id", sessionId)
+                    .last("LIMIT 1");
+
+            AgentChatHistoryEntity entity = agentChatHistoryService.getOne(wrapper);
+            if (entity != null && StringUtils.isNotBlank(entity.getMacAddress())) {
+                return deviceService.getDeviceByMacAddress(entity.getMacAddress());
+            }
+            return null;
+        } catch (Exception e) {
+            System.err.println("根据会话ID " + sessionId + " 查找设备信息失败: " + e.getMessage());
+            return null;
+        }
+    }
+}
@@ -0,0 +1,35 @@
+package xiaozhi.modules.agent.service.impl;
+
+import org.springframework.stereotype.Service;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+
+import xiaozhi.common.service.impl.BaseServiceImpl;
+import xiaozhi.modules.agent.dao.AgentContextProviderDao;
+import xiaozhi.modules.agent.entity.AgentContextProviderEntity;
+import xiaozhi.modules.agent.service.AgentContextProviderService;
+
+@Service
+public class AgentContextProviderServiceImpl extends BaseServiceImpl<AgentContextProviderDao, AgentContextProviderEntity> implements AgentContextProviderService {
+
+    @Override
+    public AgentContextProviderEntity getByAgentId(String agentId) {
+        return baseDao.selectOne(new QueryWrapper<AgentContextProviderEntity>().eq("agent_id", agentId));
+    }
+
+    @Override
+    public void saveOrUpdateByAgentId(AgentContextProviderEntity entity) {
+        AgentContextProviderEntity exist = getByAgentId(entity.getAgentId());
+        if (exist != null) {
+            entity.setId(exist.getId());
+            updateById(entity);
+        } else {
+            insert(entity);
+        }
+    }
+
+    @Override
+    public void deleteByAgentId(String agentId) {
+        baseDao.delete(new QueryWrapper<AgentContextProviderEntity>().eq("agent_id", agentId));
+    }
+}
@@ -32,10 +32,12 @@ import xiaozhi.modules.agent.dao.AgentDao;
 import xiaozhi.modules.agent.dto.AgentCreateDTO;
 import xiaozhi.modules.agent.dto.AgentDTO;
 import xiaozhi.modules.agent.dto.AgentUpdateDTO;
+import xiaozhi.modules.agent.entity.AgentContextProviderEntity;
 import xiaozhi.modules.agent.entity.AgentEntity;
 import xiaozhi.modules.agent.entity.AgentPluginMapping;
 import xiaozhi.modules.agent.entity.AgentTemplateEntity;
 import xiaozhi.modules.agent.service.AgentChatHistoryService;
+import xiaozhi.modules.agent.service.AgentContextProviderService;
 import xiaozhi.modules.agent.service.AgentPluginMappingService;
 import xiaozhi.modules.agent.service.AgentService;
 import xiaozhi.modules.agent.service.AgentTemplateService;
@@ -62,6 +64,7 @@ public class AgentServiceImpl extends BaseServiceImpl<AgentDao, AgentEntity> imp
    private final AgentChatHistoryService agentChatHistoryService;
    private final AgentTemplateService agentTemplateService;
    private final ModelProviderService modelProviderService;
+    private final AgentContextProviderService agentContextProviderService;

    @Override
    public PageData<AgentEntity> adminAgentList(Map<String, Object> params) {
@@ -85,6 +88,13 @@ public class AgentServiceImpl extends BaseServiceImpl<AgentDao, AgentEntity> imp
                agent.setChatHistoryConf(Constant.ChatHistoryConfEnum.RECORD_TEXT_AUDIO.getCode());
            }
        }
+        
+        // 查询上下文源配置
+        AgentContextProviderEntity contextProviderEntity = agentContextProviderService.getByAgentId(id);
+        if (contextProviderEntity != null) {
+            agent.setContextProviders(contextProviderEntity.getContextProviders());
+        }
+        
        // 无需额外查询插件列表，已通过SQL查询出来
        return agent;
    }
@@ -331,6 +341,14 @@ public class AgentServiceImpl extends BaseServiceImpl<AgentDao, AgentEntity> imp
            agentChatHistoryService.deleteByAgentId(existingEntity.getId(), true, false);
        }

+        // 更新上下文源配置
+        if (dto.getContextProviders() != null) {
+            AgentContextProviderEntity contextEntity = new AgentContextProviderEntity();
+            contextEntity.setAgentId(agentId);
+            contextEntity.setContextProviders(dto.getContextProviders());
+            agentContextProviderService.saveOrUpdateByAgentId(contextEntity);
+        }
+
        boolean b = validateLLMIntentParams(dto.getLlmModelId(), dto.getIntentModelId());
        if (!b) {
            throw new RenException(ErrorCode.LLM_INTENT_PARAMS_MISMATCH);
@@ -395,7 +413,20 @@ public class AgentServiceImpl extends BaseServiceImpl<AgentDao, AgentEntity> imp
            entity.setIntentModelId(template.getIntentModelId());
            entity.setSystemPrompt(template.getSystemPrompt());
            entity.setSummaryMemory(template.getSummaryMemory());
-            entity.setChatHistoryConf(template.getChatHistoryConf());
+
+            // 根据记忆模型类型设置默认的chatHistoryConf值
+            if (template.getMemModelId() != null) {
+                if (template.getMemModelId().equals("Memory_nomem")) {
+                    // 无记忆功能的模型，默认不记录聊天记录
+                    entity.setChatHistoryConf(0);
+                } else {
+                    // 有记忆功能的模型，默认记录文本和语音
+                    entity.setChatHistoryConf(2);
+                }
+            } else {
+                entity.setChatHistoryConf(template.getChatHistoryConf());
+            }
+
            entity.setLangCode(template.getLangCode());
            entity.setLanguage(template.getLanguage());
        }
@@ -5,6 +5,7 @@ import com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler;
 import io.swagger.v3.oas.annotations.media.Schema;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
+import xiaozhi.modules.agent.dto.ContextProviderDTO;
 import xiaozhi.modules.agent.entity.AgentEntity;
 import xiaozhi.modules.agent.entity.AgentPluginMapping;

@@ -21,4 +22,7 @@ public class AgentInfoVO extends AgentEntity
    @Schema(description = "插件列表Id")
    @TableField(typeHandler = JacksonTypeHandler.class)
    private List<AgentPluginMapping> functions;
+
+    @Schema(description = "上下文源配置")
+    private List<ContextProviderDTO> contextProviders;
 }
@@ -20,10 +20,12 @@ import xiaozhi.common.redis.RedisUtils;
 import xiaozhi.common.utils.ConvertUtils;
 import xiaozhi.common.utils.JsonUtils;
 import xiaozhi.modules.agent.dao.AgentVoicePrintDao;
+import xiaozhi.modules.agent.entity.AgentContextProviderEntity;
 import xiaozhi.modules.agent.entity.AgentEntity;
 import xiaozhi.modules.agent.entity.AgentPluginMapping;
 import xiaozhi.modules.agent.entity.AgentTemplateEntity;
 import xiaozhi.modules.agent.entity.AgentVoicePrintEntity;
+import xiaozhi.modules.agent.service.AgentContextProviderService;
 import xiaozhi.modules.agent.service.AgentMcpAccessPointService;
 import xiaozhi.modules.agent.service.AgentPluginMappingService;
 import xiaozhi.modules.agent.service.AgentService;
@@ -53,6 +55,7 @@ public class ConfigServiceImpl implements ConfigService {
    private final TimbreService timbreService;
    private final AgentPluginMappingService agentPluginMappingService;
    private final AgentMcpAccessPointService agentMcpAccessPointService;
+    private final AgentContextProviderService agentContextProviderService;
    private final VoiceCloneService cloneVoiceService;
    private final AgentVoicePrintDao agentVoicePrintDao;

@@ -103,6 +106,15 @@ public class ConfigServiceImpl implements ConfigService {

    @Override
    public Map<String, Object> getAgentModels(String macAddress, Map<String, String> selectedModule) {
+        // 检查是否为管理控制台请求
+        String redisKey = RedisKeys.getTmpRegisterMacKey(macAddress);
+        Object isAdminRequest = redisUtils.get(redisKey);
+        
+        if (isAdminRequest != null && "true".equals(isAdminRequest)) {
+            // 管理控制台请求，返回getConfig的结果
+            redisUtils.delete(redisKey); // 使用后清理
+            return (Map<String, Object>) getConfig(true);
+        }
        // 根据MAC地址查找设备
        DeviceEntity device = deviceService.getDeviceByMacAddress(macAddress);
        if (device == null) {
@@ -178,6 +190,13 @@ public class ConfigServiceImpl implements ConfigService {
            mcpEndpoint = mcpEndpoint.replace("/mcp/", "/call/");
            result.put("mcp_endpoint", mcpEndpoint);
        }
+        
+        // 获取上下文源配置
+        AgentContextProviderEntity contextProviderEntity = agentContextProviderService.getByAgentId(agent.getId());
+        if (contextProviderEntity != null && contextProviderEntity.getContextProviders() != null && !contextProviderEntity.getContextProviders().isEmpty()) {
+            result.put("context_providers", contextProviderEntity.getContextProviders());
+        }
+
        // 获取声纹信息
        buildVoiceprintConfig(agent.getId(), result);

@@ -72,10 +72,12 @@ public class DeviceController {
            return new Result<String>().error(ErrorCode.MCA_NOT_NULL);
        }
        // 生成六位验证码
-        String code = String.valueOf(Math.random()).substring(2, 8);
-        String key = RedisKeys.getDeviceCaptchaKey(code);
+        String code;
+        String key;
        String existsMac = null;
        do {
+            code = String.valueOf(Math.random()).substring(2, 8);
+            key = RedisKeys.getDeviceCaptchaKey(code);
            existsMac = (String) redisUtils.get(key);
        } while (StringUtils.isNotBlank(existsMac));

@@ -98,4 +98,14 @@ public interface DeviceService extends BaseService<DeviceEntity> {
     */
    void updateDeviceConnectionInfo(String agentId, String deviceId, String appVersion);

+    /**
+     * 生成WebSocket认证token
+     *
+     * @param clientId 客户端ID
+     * @param username 用户名(通常为deviceId)
+     * @return 认证token字符串
+     * @throws Exception 生成token时的异常
+     */
+    String generateWebSocketToken(String clientId, String username) throws Exception;
+
 }
@@ -1,6 +1,8 @@
 package xiaozhi.modules.device.service.impl;

 import java.nio.charset.StandardCharsets;
+import java.security.InvalidKeyException;
+import java.security.NoSuchAlgorithmException;
 import java.time.Instant;
 import java.util.Base64;
 import java.util.Date;
@@ -169,7 +171,22 @@ public class DeviceServiceImpl extends BaseServiceImpl<DeviceDao, DeviceEntity>
        DeviceReportRespDTO.Websocket websocket = new DeviceReportRespDTO.Websocket();
        // 从系统参数获取WebSocket URL，如果未配置则使用默认值
        String wsUrl = sysParamsService.getValue(Constant.SERVER_WEBSOCKET, true);
-        websocket.setToken("");
+
+        // 检查是否启用认证并生成token
+        String authEnabled = sysParamsService.getValue(Constant.SERVER_AUTH_ENABLED, true);
+        if ("true".equalsIgnoreCase(authEnabled)) {
+            try {
+                // 生成token
+                String token = generateWebSocketToken(clientId, macAddress);
+                websocket.setToken(token);
+            } catch (Exception e) {
+                log.error("生成WebSocket token失败: {}", e.getMessage());
+                websocket.setToken("");
+            }
+        } else {
+            websocket.setToken("");
+        }
+
        if (StringUtils.isBlank(wsUrl) || wsUrl.equals("null")) {
            log.error("WebSocket地址未配置，请登录智控台，在参数管理找到【server.websocket】配置");
            wsUrl = "ws://xiaozhi.server.com:8000/xiaozhi/v1/";
@@ -189,7 +206,7 @@ public class DeviceServiceImpl extends BaseServiceImpl<DeviceDao, DeviceEntity>

        // 添加MQTT UDP配置
        // 从系统参数获取MQTT Gateway地址，仅在配置有效时使用
-        String mqttUdpConfig = sysParamsService.getValue(Constant.SERVER_MQTT_GATEWAY, false);
+        String mqttUdpConfig = sysParamsService.getValue(Constant.SERVER_MQTT_GATEWAY, true);
        if (mqttUdpConfig != null && !mqttUdpConfig.equals("null") && !mqttUdpConfig.isEmpty()) {
            try {
                String groupId = deviceById != null && deviceById.getBoard() != null ? deviceById.getBoard()
@@ -494,6 +511,40 @@ public class DeviceServiceImpl extends BaseServiceImpl<DeviceDao, DeviceEntity>
        return Base64.getEncoder().encodeToString(signature);
    }

+    /**
+     * 生成WebSocket认证token 遵循Python端AuthManager的实现逻辑：token = signature.timestamp
+     * 
+     * @param clientId 客户端ID
+     * @param username 用户名 (通常为deviceId/macAddress)
+     * @return 认证token字符串
+     */
+    public String generateWebSocketToken(String clientId, String username)
+            throws NoSuchAlgorithmException, InvalidKeyException {
+        // 从系统参数获取密钥
+        String secretKey = sysParamsService.getValue(Constant.SERVER_SECRET, false);
+        if (StringUtils.isBlank(secretKey)) {
+            throw new IllegalStateException("WebSocket认证密钥未配置(server.secret)");
+        }
+
+        // 获取当前时间戳(秒)
+        long timestamp = System.currentTimeMillis() / 1000;
+
+        // 构建签名内容: clientId|username|timestamp
+        String content = String.format("%s|%s|%d", clientId, username, timestamp);
+
+        // 生成HMAC-SHA256签名
+        Mac hmac = Mac.getInstance("HmacSHA256");
+        SecretKeySpec keySpec = new SecretKeySpec(secretKey.getBytes(StandardCharsets.UTF_8), "HmacSHA256");
+        hmac.init(keySpec);
+        byte[] signature = hmac.doFinal(content.getBytes(StandardCharsets.UTF_8));
+
+        // Base64 URL-safe编码签名(去除填充符=)
+        String signatureBase64 = Base64.getUrlEncoder().withoutPadding().encodeToString(signature);
+
+        // 返回格式: signature.timestamp
+        return String.format("%s.%d", signatureBase64, timestamp);
+    }
+
    /**
     * 构建MQTT配置信息
     * 
@@ -504,7 +555,7 @@ public class DeviceServiceImpl extends BaseServiceImpl<DeviceDao, DeviceEntity>
    private DeviceReportRespDTO.MQTT buildMqttConfig(String macAddress, String groupId)
            throws Exception {
        // 从环境变量或系统参数获取签名密钥
-        String signatureKey = sysParamsService.getValue("server.mqtt_signature_key", false);
+        String signatureKey = sysParamsService.getValue("server.mqtt_signature_key", true);
        if (StringUtils.isBlank(signatureKey)) {
            log.warn("缺少MQTT_SIGNATURE_KEY，跳过MQTT配置生成");
            return null;
@@ -0,0 +1,22 @@
+package xiaozhi.modules.knowledge.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import xiaozhi.modules.knowledge.rag.KnowledgeBaseAdapterFactory;
+
+/**
+ * 知识库配置类
+ * 配置知识库相关的Bean
+ */
+@Configuration
+public class KnowledgeBaseConfig {
+
+    /**
+     * 提供KnowledgeBaseAdapterFactory的Bean实例
+     * @return KnowledgeBaseAdapterFactory实例
+     */
+    @Bean
+    public KnowledgeBaseAdapterFactory knowledgeBaseAdapterFactory() {
+        return new KnowledgeBaseAdapterFactory();
+    }
+}
@@ -77,7 +77,7 @@ public class KnowledgeFilesDTO implements Serializable {
            return STATUS_UNSTART;
        }

-        // 根据run字段的值直接映射到对应的状态码
+        // RAGFlow根据run字段的值直接映射到对应的状态码
        switch (run.toUpperCase()) {
            case "RUNNING":
                return STATUS_RUNNING;
@@ -0,0 +1,200 @@
+package xiaozhi.modules.knowledge.rag;
+
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.web.multipart.MultipartFile;
+
+import xiaozhi.common.page.PageData;
+import xiaozhi.modules.knowledge.dto.KnowledgeFilesDTO;
+
+/**
+ * 知识库API适配器抽象基类
+ * 定义通用的知识库操作接口，支持多种后端API实现
+ */
+public abstract class KnowledgeBaseAdapter {
+
+        /**
+         * 获取适配器类型标识
+         * 
+         * @return 适配器类型（如：ragflow, milvus, pinecone等）
+         */
+        public abstract String getAdapterType();
+
+        /**
+         * 初始化适配器配置
+         * 
+         * @param config 配置参数
+         */
+        public abstract void initialize(Map<String, Object> config);
+
+        /**
+         * 验证配置是否有效
+         * 
+         * @param config 配置参数
+         * @return 验证结果
+         */
+        public abstract boolean validateConfig(Map<String, Object> config);
+
+        /**
+         * 分页查询文档列表
+         * 
+         * @param datasetId   知识库ID
+         * @param queryParams 查询参数
+         * @param page        页码
+         * @param limit       每页数量
+         * @return 分页数据
+         */
+        public abstract PageData<KnowledgeFilesDTO> getDocumentList(String datasetId,
+                        Map<String, Object> queryParams,
+                        Integer page,
+                        Integer limit);
+
+        /**
+         * 根据文档ID获取文档详情
+         * 
+         * @param datasetId 知识库ID
+         * @return 文档详情
+         */
+        public abstract KnowledgeFilesDTO getDocumentById(String datasetId, String documentId);
+
+        /**
+         * 上传文档到知识库
+         * 
+         * @param datasetId    知识库ID
+         * @param file         上传的文件
+         * @param name         文档名称
+         * @param metaFields   元数据字段
+         * @param chunkMethod  分块方法
+         * @param parserConfig 解析器配置
+         * @return 上传的文档信息
+         */
+        public abstract KnowledgeFilesDTO uploadDocument(String datasetId,
+                        MultipartFile file,
+                        String name,
+                        Map<String, Object> metaFields,
+                        String chunkMethod,
+                        Map<String, Object> parserConfig);
+
+        /**
+         * 根据状态分页查询文档列表
+         * 
+         * @param datasetId 知识库ID
+         * @param status    文档解析状态
+         * @param page      页码
+         * @param limit     每页数量
+         * @return 分页数据
+         */
+        public abstract PageData<KnowledgeFilesDTO> getDocumentListByStatus(String datasetId,
+                        Integer status,
+                        Integer page,
+                        Integer limit);
+
+        /**
+         * 删除文档
+         * 
+         * @param datasetId  知识库ID
+         * @param documentId 文档ID
+         */
+        public abstract void deleteDocument(String datasetId, String documentId);
+
+        /**
+         * 解析文档（切块）
+         * 
+         * @param datasetId   知识库ID
+         * @param documentIds 文档ID列表
+         * @return 解析结果
+         */
+        public abstract boolean parseDocuments(String datasetId, List<String> documentIds);
+
+        /**
+         * 列出指定文档的切片
+         * 
+         * @param datasetId  知识库ID
+         * @param documentId 文档ID
+         * @param keywords   关键词过滤
+         * @param page       页码
+         * @param pageSize   每页数量
+         * @param chunkId    切片ID
+         * @return 切片列表信息
+         */
+        public abstract Map<String, Object> listChunks(String datasetId,
+                        String documentId,
+                        String keywords,
+                        Integer page,
+                        Integer pageSize,
+                        String chunkId);
+
+        /**
+         * 召回测试 - 从知识库中检索相关切片
+         * 
+         * @param question        用户查询
+         * @param datasetIds      数据集ID列表
+         * @param documentIds     文档ID列表
+         * @param retrievalParams 检索参数
+         * @return 召回测试结果
+         */
+        public abstract Map<String, Object> retrievalTest(String question,
+                        List<String> datasetIds,
+                        List<String> documentIds,
+                        Map<String, Object> retrievalParams);
+
+        /**
+         * 测试连接
+         * 
+         * @return 连接测试结果
+         */
+        public abstract boolean testConnection();
+
+        /**
+         * 获取适配器状态信息
+         * 
+         * @return 状态信息
+         */
+        public abstract Map<String, Object> getStatus();
+
+        /**
+         * 获取支持的配置参数
+         * 
+         * @return 配置参数说明
+         */
+        public abstract Map<String, Object> getSupportedConfig();
+
+        /**
+         * 获取默认配置
+         * 
+         * @return 默认配置
+         */
+        public abstract Map<String, Object> getDefaultConfig();
+
+        /**
+         * 创建数据集
+         * 
+         * @param createParams 创建参数
+         * @return 数据集ID
+         */
+        public abstract String createDataset(Map<String, Object> createParams);
+
+        /**
+         * 更新数据集
+         * 
+         * @param datasetId    数据集ID
+         * @param updateParams 更新参数
+         */
+        public abstract void updateDataset(String datasetId, Map<String, Object> updateParams);
+
+        /**
+         * 删除数据集
+         * 
+         * @param datasetId 数据集ID
+         */
+        public abstract void deleteDataset(String datasetId);
+
+        /**
+         * 获取数据集的文档数量
+         * 
+         * @param datasetId 数据集ID
+         * @return 文档数量
+         */
+        public abstract Integer getDocumentCount(String datasetId);
+}
@@ -0,0 +1,197 @@
+package xiaozhi.modules.knowledge.rag;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import lombok.extern.slf4j.Slf4j;
+import xiaozhi.common.exception.ErrorCode;
+import xiaozhi.common.exception.RenException;
+
+/**
+ * 知识库适配器工厂类
+ * 负责创建和管理不同类型的知识库API适配器
+ */
+@Slf4j
+public class KnowledgeBaseAdapterFactory {
+
+    // 注册的适配器类型映射
+    private static final Map<String, Class<? extends KnowledgeBaseAdapter>> adapterRegistry = new HashMap<>();
+
+    // 适配器实例缓存
+    private static final Map<String, KnowledgeBaseAdapter> adapterCache = new ConcurrentHashMap<>();
+
+    static {
+        // 注册内置适配器类型
+        registerAdapter("ragflow", xiaozhi.modules.knowledge.rag.impl.RAGFlowAdapter.class);
+        // 可以在这里注册更多适配器类型
+    }
+
+    /**
+     * 注册新的适配器类型
+     * 
+     * @param adapterType  适配器类型标识
+     * @param adapterClass 适配器类
+     */
+    public static void registerAdapter(String adapterType, Class<? extends KnowledgeBaseAdapter> adapterClass) {
+        if (adapterRegistry.containsKey(adapterType)) {
+            log.warn("适配器类型 '{}' 已存在，将被覆盖", adapterType);
+        }
+        adapterRegistry.put(adapterType, adapterClass);
+        log.info("注册适配器类型: {} -> {}", adapterType, adapterClass.getSimpleName());
+    }
+
+    /**
+     * 获取适配器实例
+     * 
+     * @param adapterType 适配器类型
+     * @param config      配置参数
+     * @return 适配器实例
+     */
+    public static KnowledgeBaseAdapter getAdapter(String adapterType, Map<String, Object> config) {
+        String cacheKey = buildCacheKey(adapterType, config);
+
+        // 检查缓存中是否已存在实例
+        if (adapterCache.containsKey(cacheKey)) {
+            log.debug("从缓存获取适配器实例: {}", cacheKey);
+            return adapterCache.get(cacheKey);
+        }
+
+        // 创建新的适配器实例
+        KnowledgeBaseAdapter adapter = createAdapter(adapterType, config);
+
+        // 缓存适配器实例
+        adapterCache.put(cacheKey, adapter);
+        log.info("创建并缓存适配器实例: {}", cacheKey);
+
+        return adapter;
+    }
+
+    /**
+     * 获取适配器实例（无配置）
+     * 
+     * @param adapterType 适配器类型
+     * @return 适配器实例
+     */
+    public static KnowledgeBaseAdapter getAdapter(String adapterType) {
+        return getAdapter(adapterType, null);
+    }
+
+    /**
+     * 获取所有已注册的适配器类型
+     * 
+     * @return 适配器类型集合
+     */
+    public static Set<String> getRegisteredAdapterTypes() {
+        return adapterRegistry.keySet();
+    }
+
+    /**
+     * 检查适配器类型是否已注册
+     * 
+     * @param adapterType 适配器类型
+     * @return 是否已注册
+     */
+    public static boolean isAdapterTypeRegistered(String adapterType) {
+        return adapterRegistry.containsKey(adapterType);
+    }
+
+    /**
+     * 清除适配器缓存
+     */
+    public static void clearCache() {
+        int cacheSize = adapterCache.size();
+        adapterCache.clear();
+        log.info("清除适配器缓存，共清除 {} 个实例", cacheSize);
+    }
+
+    /**
+     * 移除特定适配器类型的缓存
+     * 
+     * @param adapterType 适配器类型
+     */
+    public static void removeCacheByType(String adapterType) {
+        int removedCount = 0;
+        for (String cacheKey : adapterCache.keySet()) {
+            if (cacheKey.startsWith(adapterType + "@")) {
+                adapterCache.remove(cacheKey);
+                removedCount++;
+            }
+        }
+        log.info("移除适配器类型 '{}' 的缓存，共移除 {} 个实例", adapterType, removedCount);
+    }
+
+    /**
+     * 获取适配器工厂状态信息
+     * 
+     * @return 状态信息
+     */
+    public static Map<String, Object> getFactoryStatus() {
+        Map<String, Object> status = new HashMap<>();
+        status.put("registeredAdapterTypes", adapterRegistry.keySet());
+        status.put("cachedAdapterCount", adapterCache.size());
+        status.put("cacheKeys", adapterCache.keySet());
+        return status;
+    }
+
+    /**
+     * 创建适配器实例
+     * 
+     * @param adapterType 适配器类型
+     * @param config      配置参数
+     * @return 适配器实例
+     */
+    private static KnowledgeBaseAdapter createAdapter(String adapterType, Map<String, Object> config) {
+        if (!adapterRegistry.containsKey(adapterType)) {
+            throw new RenException(ErrorCode.RAG_ADAPTER_TYPE_NOT_SUPPORTED,
+                    "不支持的适配器类型: " + adapterType);
+        }
+
+        try {
+            Class<? extends KnowledgeBaseAdapter> adapterClass = adapterRegistry.get(adapterType);
+            KnowledgeBaseAdapter adapter = adapterClass.getDeclaredConstructor().newInstance();
+
+            // 初始化适配器
+            if (config != null) {
+                adapter.initialize(config);
+
+                // 验证配置
+                if (!adapter.validateConfig(config)) {
+                    throw new RenException(ErrorCode.RAG_CONFIG_VALIDATION_FAILED,
+                            "适配器配置验证失败: " + adapterType);
+                }
+            }
+
+            log.info("成功创建适配器实例: {}", adapterType);
+            return adapter;
+
+        } catch (Exception e) {
+            log.error("创建适配器实例失败: {}", adapterType, e);
+            throw new RenException(ErrorCode.RAG_ADAPTER_CREATION_FAILED,
+                    "创建适配器失败: " + adapterType + ", 错误: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 构建缓存键
+     * 
+     * @param adapterType 适配器类型
+     * @param config      配置参数
+     * @return 缓存键
+     */
+    private static String buildCacheKey(String adapterType, Map<String, Object> config) {
+        if (config == null || config.isEmpty()) {
+            return adapterType + "@default";
+        }
+
+        // 基于配置参数生成缓存键
+        StringBuilder keyBuilder = new StringBuilder(adapterType + "@");
+
+        // 使用配置的哈希值作为缓存键的一部分
+        int configHash = config.hashCode();
+        keyBuilder.append(configHash);
+
+        return keyBuilder.toString();
+    }
+}
@@ -35,6 +35,8 @@ import xiaozhi.common.utils.MessageUtils;
 import xiaozhi.modules.knowledge.dao.KnowledgeBaseDao;
 import xiaozhi.modules.knowledge.dto.KnowledgeBaseDTO;
 import xiaozhi.modules.knowledge.entity.KnowledgeBaseEntity;
+import xiaozhi.modules.knowledge.rag.KnowledgeBaseAdapter;
+import xiaozhi.modules.knowledge.rag.KnowledgeBaseAdapterFactory;
 import xiaozhi.modules.knowledge.service.KnowledgeBaseService;
 import xiaozhi.modules.model.dao.ModelConfigDao;
 import xiaozhi.modules.model.entity.ModelConfigEntity;
@@ -106,7 +108,7 @@ public class KnowledgeBaseServiceImpl extends BaseServiceImpl<KnowledgeBaseDao,
        if (pageData != null && pageData.getList() != null) {
            for (KnowledgeBaseDTO knowledgeBase : pageData.getList()) {
                try {
-                    Integer documentCount = getDocumentCountFromRAGFlow(knowledgeBase.getDatasetId(),
+                    Integer documentCount = getDocumentCountFromRAG(knowledgeBase.getDatasetId(),
                            knowledgeBase.getRagModelId());
                    knowledgeBase.setDocumentCount(documentCount);
                } catch (Exception e) {
@@ -146,10 +148,10 @@ public class KnowledgeBaseServiceImpl extends BaseServiceImpl<KnowledgeBaseDao,
        checkDuplicateKnowledgeBaseName(knowledgeBaseDTO, null);

        String datasetId = null;
-        // 调用RAGFlow API创建数据集
+        // 调用RAG API创建数据集
        try {
            Map<String, Object> ragConfig = getValidatedRAGConfig(knowledgeBaseDTO.getRagModelId());
-            datasetId = createDatasetInRAGFlow(
+            datasetId = createDatasetInRAG(
                    knowledgeBaseDTO.getName(),
                    knowledgeBaseDTO.getDescription(),
                    ragConfig);
@@ -162,13 +164,13 @@ public class KnowledgeBaseServiceImpl extends BaseServiceImpl<KnowledgeBaseDao,
        KnowledgeBaseEntity existingEntity = knowledgeBaseDao.selectOne(
                new QueryWrapper<KnowledgeBaseEntity>().eq("dataset_id", datasetId));
        if (existingEntity != null) {
-            // 如果datasetId已存在，删除RAGFlow中的数据集并抛出异常
+            // 如果datasetId已存在，删除RAG中的数据集并抛出异常
            try {
                Map<String, Object> ragConfig = getValidatedRAGConfig(knowledgeBaseDTO.getRagModelId());
-                deleteDatasetInRAGFlow(datasetId, ragConfig);
+                deleteDatasetInRAG(datasetId, ragConfig);
            } catch (Exception deleteException) {
                // 提供更详细的错误信息，包括异常类型和消息
-                String errorMessage = "删除重复datasetId的RAGFlow数据集失败: " + deleteException.getClass().getSimpleName();
+                String errorMessage = "删除重复datasetId的RAG数据集失败: " + deleteException.getClass().getSimpleName();
                if (deleteException.getMessage() != null) {
                    errorMessage += " - " + deleteException.getMessage();
                }
@@ -219,17 +221,17 @@ public class KnowledgeBaseServiceImpl extends BaseServiceImpl<KnowledgeBaseDao,
                // 先校验RAG配置
                Map<String, Object> ragConfig = getValidatedRAGConfig(knowledgeBaseDTO.getRagModelId());

-                // 调用RAGFlow API更新数据集
-                updateDatasetInRAGFlow(
+                // 调用RAG API更新数据集
+                updateDatasetInRAG(
                        knowledgeBaseDTO.getDatasetId(),
                        knowledgeBaseDTO.getName(),
                        knowledgeBaseDTO.getDescription(),
                        ragConfig);

-                log.info("RAGFlow API更新成功，datasetId: {}", knowledgeBaseDTO.getDatasetId());
+                log.info("RAG API更新成功，datasetId: {}", knowledgeBaseDTO.getDatasetId());
            } catch (Exception e) {
                // 提供更详细的错误信息，包括异常类型和消息
-                String errorMessage = "更新RAGFlow数据集失败: " + e.getClass().getSimpleName();
+                String errorMessage = "更新RAG数据集失败: " + e.getClass().getSimpleName();
                if (e.getMessage() != null) {
                    errorMessage += " - " + e.getMessage();
                }
@@ -237,7 +239,7 @@ public class KnowledgeBaseServiceImpl extends BaseServiceImpl<KnowledgeBaseDao,
                throw e;
            }
        } else {
-            log.warn("datasetId或ragModelId为空，跳过RAGFlow更新");
+            log.warn("datasetId或ragModelId为空，跳过RAG更新");
        }

        KnowledgeBaseEntity entity = ConvertUtils.sourceToTarget(knowledgeBaseDTO, KnowledgeBaseEntity.class);
@@ -288,19 +290,19 @@ public class KnowledgeBaseServiceImpl extends BaseServiceImpl<KnowledgeBaseDao,
        log.info("找到记录: ID={}, datasetId={}, ragModelId={}",
                entity.getId(), entity.getDatasetId(), entity.getRagModelId());

-        // 先调用RAGFlow API删除数据集
+        // 先调用RAG API删除数据集
        boolean apiDeleteSuccess = false;
        if (StringUtils.isNotBlank(entity.getDatasetId()) && StringUtils.isNotBlank(entity.getRagModelId())) {
            try {
-                log.info("开始调用RAGFlow API删除数据集");
+                log.info("开始调用RAG API删除数据集");
                // 在删除前进行RAG配置校验
                Map<String, Object> ragConfig = getValidatedRAGConfig(entity.getRagModelId());
-                deleteDatasetInRAGFlow(entity.getDatasetId(), ragConfig);
-                log.info("RAGFlow API删除调用完成");
+                deleteDatasetInRAG(entity.getDatasetId(), ragConfig);
+                log.info("RAG API删除调用完成");
                apiDeleteSuccess = true;
            } catch (Exception e) {
                // 提供更详细的错误信息，包括异常类型和消息
-                String errorMessage = "删除RAGFlow数据集失败: " + e.getClass().getSimpleName();
+                String errorMessage = "删除RAG数据集失败: " + e.getClass().getSimpleName();
                if (e.getMessage() != null) {
                    errorMessage += " - " + e.getMessage();
                }
@@ -308,7 +310,7 @@ public class KnowledgeBaseServiceImpl extends BaseServiceImpl<KnowledgeBaseDao,
                throw e;
            }
        } else {
-            log.warn("datasetId或ragModelId为空，跳过RAGFlow删除");
+            log.warn("datasetId或ragModelId为空，跳过RAG删除");
            apiDeleteSuccess = true; // 没有RAG数据集，视为成功
        }

@@ -432,289 +434,133 @@ public class KnowledgeBaseServiceImpl extends BaseServiceImpl<KnowledgeBaseDao,
    }

    /**
-     * 调用RAGFlow API创建数据集
+     * 从RAG配置中提取适配器类型
+     * 
+     * @param config RAG配置
+     * @return 适配器类型
     */
-    private String createDatasetInRAGFlow(String name, String description, Map<String, Object> ragConfig) {
-        String datasetId = null;
-        String baseUrl = (String) ragConfig.get("base_url");
-        String apiKey = (String) ragConfig.get("api_key");
-
-        log.info("开始调用RAGFlow API创建数据集, name: {}", name);
-        log.debug("RAGFlow配置 - baseUrl: {}, apiKey: {}", baseUrl, StringUtils.isBlank(apiKey) ? "未配置" : "已配置");
-
-        // 构建请求URL
-        String url = baseUrl + "/api/v1/datasets";
-        log.debug("请求URL: {}", url);
-
-        // 构建请求体
-        Map<String, Object> requestBody = new HashMap<>();
-        String username = SecurityUser.getUser().getUsername();
-        requestBody.put("name", username + "_" + name);
-        if (StringUtils.isNotBlank(description)) {
-            requestBody.put("description", description);
-        }
-        log.debug("请求体: {}", requestBody);
-
-        // 设置请求头
-        HttpHeaders headers = new HttpHeaders();
-        headers.setContentType(MediaType.APPLICATION_JSON);
-        headers.set("Authorization", "Bearer " + apiKey);
-
-        HttpEntity<Map<String, Object>> requestEntity = new HttpEntity<>(requestBody, headers);
-
-        // 发送POST请求
-        log.info("发送POST请求到RAGFlow API...");
-        ResponseEntity<String> response;
-        try {
-            response = restTemplate.exchange(url, HttpMethod.POST, requestEntity, String.class);
-        } catch (Exception e) {
-            String errorMessage = url + e.getMessage();
-            log.error(errorMessage, e);
-            throw new RenException(ErrorCode.RAG_API_ERROR, errorMessage);
+    private String extractAdapterType(Map<String, Object> config) {
+        if (config == null) {
+            throw new RenException(ErrorCode.RAG_CONFIG_NOT_FOUND);
        }

-        log.info("RAGFlow API响应状态码: {}", response.getStatusCode());
-        log.debug("RAGFlow API响应内容: {}", response.getBody());
+        // 从配置中提取适配器类型
+        String adapterType = (String) config.get("type");

-        if (!response.getStatusCode().is2xxSuccessful()) {
-            String errorMessage = response.getStatusCode() + ", 响应内容: " + response.getBody();
-            log.error(errorMessage);
-            throw new RenException(ErrorCode.RAG_API_ERROR, errorMessage);
+        // 验证适配器类型是否存在且非空
+        if (StringUtils.isBlank(adapterType)) {
+            throw new RenException(ErrorCode.RAG_ADAPTER_TYPE_NOT_FOUND);
        }

-        // 解析响应体，提取datasetId
-        String responseBody = response.getBody();
-        if (StringUtils.isNotBlank(responseBody)) {
-            try {
-                // 解析RAGFlow API响应，支持多种可能的字段名
-                ObjectMapper objectMapper = new ObjectMapper();
-                Map<String, Object> responseMap = objectMapper.readValue(responseBody, Map.class);
-
-                log.debug("RAGFlow API响应解析结果: {}", responseMap);
-
-                // 首先检查响应码
-                Integer code = (Integer) responseMap.get("code");
-                String message = (String) responseMap.get("message");
-                if (code != null && code == 0) {
-                    // 响应码为0表示成功，从data字段中获取datasetId
-                    Object dataObj = responseMap.get("data");
-                    if (dataObj instanceof Map) {
-                        Map<String, Object> dataMap = (Map<String, Object>) dataObj;
-                        datasetId = (String) dataMap.get("id");
-
-                        if (StringUtils.isBlank(datasetId)) {
-                            // 如果id字段为空，尝试其他可能的字段名
-                            datasetId = (String) dataMap.get("dataset_id");
-                            datasetId = (String) dataMap.get("datasetId");
-                        }
-                    }
-                } else {
-                    // 如果响应码不为0，说明API调用失败
-                    String errorMessage = code + (message != null ? message : "null");
-                    log.error(errorMessage);
-                    throw new RenException(ErrorCode.RAG_API_ERROR, errorMessage);
-                }
-
-                log.info("从RAGFlow API响应中解析出datasetId: {}", datasetId);
-                log.debug("完整响应内容: {}", responseBody);
-            } catch (IOException e) {
-                // 构建详细的错误信息，包含异常类型和消息
-                String baseErrorMessage = e.getClass().getSimpleName();
-                String errorMessage = baseErrorMessage + (e.getMessage() != null ? ": " + e.getMessage() : "");
-                log.error(errorMessage, e);
-                throw new RenException(ErrorCode.RAG_API_ERROR, errorMessage);
-            } catch (Exception e) {
-                // 构建详细的错误信息，包含异常类型和消息
-                String baseErrorMessage = e.getClass().getSimpleName();
-                String errorMessage = baseErrorMessage + (e.getMessage() != null ? ": " + e.getMessage() : "");
-                log.error(errorMessage, e);
-                // 如果解析失败，但响应体不为空，尝试直接使用响应体作为错误信息
-                String finalErrorMessage = responseBody;
-                if (e.getMessage() != null) {
-                    finalErrorMessage += errorMessage;
-                }
-                throw new RenException(ErrorCode.RAG_API_ERROR, finalErrorMessage);
-            }
+        // 验证适配器类型是否已注册
+        if (!KnowledgeBaseAdapterFactory.isAdapterTypeRegistered(adapterType)) {
+            throw new RenException(ErrorCode.RAG_ADAPTER_TYPE_NOT_SUPPORTED,
+                    "不支持的适配器类型: " + adapterType);
        }

-        if (StringUtils.isBlank(datasetId)) {
-            log.error("无法从RAGFlow API响应中获取datasetId，响应内容: {}", responseBody);
-            throw new RenException(ErrorCode.RAG_DATASET_ID_NOT_NULL);
-        }
-        log.info("RAGFlow数据集创建成功，datasetId: {}", datasetId);
-
-        return datasetId;
+        return adapterType;
    }

    /**
-     * 调用RAGFlow API更新数据集
+     * 使用适配器创建数据集
     */
-    private void updateDatasetInRAGFlow(String datasetId, String name, String description,
+    private String createDatasetInRAG(String name, String description, Map<String, Object> ragConfig) {
+        log.info("开始使用适配器创建数据集, name: {}", name);
+
+        try {
+            // 从RAG配置中提取适配器类型
+            String adapterType = extractAdapterType(ragConfig);
+
+            // 使用适配器工厂获取适配器实例
+            KnowledgeBaseAdapter adapter = KnowledgeBaseAdapterFactory.getAdapter(adapterType, ragConfig);
+
+            // 构建数据集创建参数
+            Map<String, Object> createParams = new HashMap<>();
+            String username = SecurityUser.getUser().getUsername();
+            createParams.put("name", username + "_" + name);
+            if (StringUtils.isNotBlank(description)) {
+                createParams.put("description", description);
+            }
+
+            // 调用适配器的创建数据集方法
+            String datasetId = adapter.createDataset(createParams);
+
+            log.info("数据集创建成功，datasetId: {}", datasetId);
+            return datasetId;
+
+        } catch (Exception e) {
+            // 直接传递底层适配器的详细错误信息
+            log.error("创建数据集失败", e);
+            if (e instanceof RenException) {
+                throw (RenException) e;
+            }
+            throw new RenException(ErrorCode.RAG_API_ERROR, e.getMessage());
+        }
+    }
+
+    /**
+     * 使用适配器更新数据集
+     */
+    private void updateDatasetInRAG(String datasetId, String name, String description,
            Map<String, Object> ragConfig) {
-        String baseUrl = (String) ragConfig.get("base_url");
-        String apiKey = (String) ragConfig.get("api_key");
+        log.info("开始使用适配器更新数据集，datasetId: {}, name: {}", datasetId, name);

-        log.info("开始调用RAGFlow API更新数据集，datasetId: {}, name: {}", datasetId, name);
-        log.debug("RAGFlow配置 - baseUrl: {}, apiKey: {}", baseUrl, StringUtils.isBlank(apiKey) ? "未配置" : "已配置");
-
-        // 构建请求URL
-        String url = baseUrl + "/api/v1/datasets/" + datasetId;
-        log.debug("请求URL: {}", url);
-        // 构建请求体
-        Map<String, Object> requestBody = new HashMap<>();
-        requestBody.put("dataset_id", datasetId);
-        String username = SecurityUser.getUser().getUsername();
-        requestBody.put("name", username + "_" + name);
-        if (StringUtils.isNotBlank(description)) {
-            requestBody.put("description", description);
-        }
-        log.debug("请求体: {}", requestBody);
-
-        // 设置请求头
-        HttpHeaders headers = new HttpHeaders();
-        headers.setContentType(MediaType.APPLICATION_JSON);
-        headers.set("Authorization", "Bearer " + apiKey);
-
-        HttpEntity<Map<String, Object>> requestEntity = new HttpEntity<>(requestBody, headers);
-
-        // 发送PUT请求
-        log.info("发送PUT请求到RAGFlow API...");
-        ResponseEntity<String> response;
        try {
-            response = restTemplate.exchange(url, HttpMethod.PUT, requestEntity, String.class);
-        } catch (Exception e) {
-            String errorMessage = url + e.getMessage();
-            log.error(errorMessage, e);
-            throw new RenException(ErrorCode.RAG_API_ERROR, errorMessage);
-        }
+            // 从RAG配置中提取适配器类型
+            String adapterType = extractAdapterType(ragConfig);

-        log.info("RAGFlow API响应状态码: {}", response.getStatusCode());
-        log.debug("RAGFlow API响应内容: {}", response.getBody());
+            // 使用适配器工厂获取适配器实例
+            KnowledgeBaseAdapter adapter = KnowledgeBaseAdapterFactory.getAdapter(adapterType, ragConfig);

-        if (!response.getStatusCode().is2xxSuccessful()) {
-            String errorMessage = response.getStatusCode() + ", 响应内容: " + response.getBody();
-            log.error(errorMessage);
-            throw new RenException(ErrorCode.RAG_API_ERROR, errorMessage);
-        }
-
-        // 解析响应体，验证操作是否真正成功
-        String responseBody = response.getBody();
-        if (responseBody != null) {
-            try {
-                Map<String, Object> responseMap = objectMapper.readValue(responseBody, Map.class);
-                Integer code = (Integer) responseMap.get("code");
-                String message = (String) responseMap.get("message");
-
-                if (code != null && code != 0) {
-                    String errorMessage = code + (message != null ? message : "null");
-                    log.error(errorMessage);
-                    throw new RenException(ErrorCode.RAG_API_ERROR, errorMessage);
-                }
-            } catch (IOException e) {
-                // 构建详细的错误信息，包含异常类型和消息
-                String baseErrorMessage = e.getClass().getSimpleName();
-                String errorMessage = baseErrorMessage + (e.getMessage() != null ? ": " + e.getMessage() : "");
-                log.error(errorMessage, e);
-                throw new RenException(ErrorCode.RAG_API_ERROR, errorMessage);
-            } catch (Exception e) {
-                // 构建详细的错误信息，包含异常类型和消息
-                String baseErrorMessage = e.getClass().getSimpleName();
-                String errorMessage = baseErrorMessage + (e.getMessage() != null ? ": " + e.getMessage() : "");
-                log.error(errorMessage, e);
-                // 如果解析失败，但响应体不为空，尝试直接使用响应体作为错误信息
-                String finalErrorMessage = responseBody;
-                if (e.getMessage() != null) {
-                    finalErrorMessage += errorMessage;
-                }
-                throw new RenException(ErrorCode.RAG_API_ERROR, finalErrorMessage);
+            // 构建数据集更新参数
+            Map<String, Object> updateParams = new HashMap<>();
+            String username = SecurityUser.getUser().getUsername();
+            updateParams.put("name", username + "_" + name);
+            if (StringUtils.isNotBlank(description)) {
+                updateParams.put("description", description);
            }
+
+            // 调用适配器的更新数据集方法
+            adapter.updateDataset(datasetId, updateParams);
+
+            log.info("数据集更新成功，datasetId: {}", datasetId);
+
+        } catch (Exception e) {
+            // 直接传递底层适配器的详细错误信息
+            log.error("更新数据集失败", e);
+            if (e instanceof RenException) {
+                throw (RenException) e;
+            }
+            throw new RenException(ErrorCode.RAG_API_ERROR, e.getMessage());
        }
-
-        log.info("RAGFlow数据集更新成功，datasetId: {}", datasetId);
-
    }

    /**
-     * 调用RAGFlow API删除数据集
+     * 使用适配器删除数据集
     */
-    private void deleteDatasetInRAGFlow(String datasetId, Map<String, Object> ragConfig) {
-        String baseUrl = (String) ragConfig.get("base_url");
-        String apiKey = (String) ragConfig.get("api_key");
+    private void deleteDatasetInRAG(String datasetId, Map<String, Object> ragConfig) {
+        log.info("开始使用适配器删除数据集，datasetId: {}", datasetId);

-        log.info("开始调用RAGFlow API删除数据集，datasetId: {}", datasetId);
-        log.debug("RAGFlow配置 - baseUrl: {}, apiKey: {}", baseUrl, StringUtils.isBlank(apiKey) ? "未配置" : "已配置");
-
-        // 构建请求URL
-        String url = baseUrl + "/api/v1/datasets";
-        log.debug("请求URL: {}", url);
-
-        // 构建请求体
-        Map<String, Object> requestBody = new HashMap<>();
-        requestBody.put("ids", List.of(datasetId));
-        log.debug("请求体: {}", requestBody);
-
-        // 设置请求头
-        HttpHeaders headers = new HttpHeaders();
-        headers.setContentType(MediaType.APPLICATION_JSON);
-        headers.set("Authorization", "Bearer " + apiKey);
-
-        HttpEntity<Map<String, Object>> requestEntity = new HttpEntity<>(requestBody, headers);
-
-        // 发送DELETE请求
-        log.info("发送DELETE请求到RAGFlow API...");
-        ResponseEntity<String> response;
        try {
-            response = restTemplate.exchange(url, HttpMethod.DELETE, requestEntity, String.class);
+            // 从RAG配置中提取适配器类型
+            String adapterType = extractAdapterType(ragConfig);
+
+            // 使用适配器工厂获取适配器实例
+            KnowledgeBaseAdapter adapter = KnowledgeBaseAdapterFactory.getAdapter(adapterType, ragConfig);
+
+            // 调用适配器的删除数据集方法
+            adapter.deleteDataset(datasetId);
+
+            log.info("数据集删除成功，datasetId: {}", datasetId);
+
        } catch (Exception e) {
-            String errorMessage = url + e.getMessage();
-            log.error(errorMessage, e);
-            throw new RenException(ErrorCode.RAG_API_ERROR, errorMessage);
-        }
-
-        log.info("RAGFlow API响应状态码: {}", response.getStatusCode());
-        log.debug("RAGFlow API响应内容: {}", response.getBody());
-
-        if (!response.getStatusCode().is2xxSuccessful()) {
-            String errorMessage = response.getStatusCode() + response.getBody();
-            log.error(errorMessage);
-            throw new RenException(ErrorCode.RAG_API_ERROR, errorMessage);
-        }
-
-        // 解析响应体，验证操作是否真正成功
-        String responseBody = response.getBody();
-        if (responseBody != null) {
-            try {
-                Map<String, Object> responseMap = objectMapper.readValue(responseBody, Map.class);
-                Integer code = (Integer) responseMap.get("code");
-                String message = (String) responseMap.get("message");
-
-                if (code != null && code != 0) {
-                    String errorMessage = code + (message != null ? message : "null");
-                    log.error(errorMessage);
-                    throw new RenException(ErrorCode.RAG_API_ERROR, errorMessage);
-                }
-            } catch (IOException e) {
-                // 构建详细的错误信息，包含异常类型和消息
-                String baseErrorMessage = e.getClass().getSimpleName();
-                String errorMessage = baseErrorMessage + (e.getMessage() != null ? ": " + e.getMessage() : "");
-                log.error(errorMessage, e);
-                throw new RenException(ErrorCode.RAG_API_ERROR, errorMessage);
-            } catch (Exception e) {
-                // 构建详细的错误信息，包含异常类型和消息
-                String baseErrorMessage = e.getClass().getSimpleName();
-                String errorMessage = baseErrorMessage + (e.getMessage() != null ? ": " + e.getMessage() : "");
-                log.error(errorMessage, e);
-                // 如果解析失败，但响应体不为空，尝试直接使用响应体作为错误信息
-                String finalErrorMessage = responseBody;
-                if (e.getMessage() != null) {
-                    finalErrorMessage += errorMessage;
-                }
-                throw new RenException(ErrorCode.RAG_API_ERROR, finalErrorMessage);
+            // 直接传递底层适配器的详细错误信息
+            log.error("删除数据集失败", e);
+            if (e instanceof RenException) {
+                throw (RenException) e;
            }
+            throw new RenException(ErrorCode.RAG_API_ERROR, e.getMessage());
        }
-
-        log.info("RAGFlow数据集删除成功，datasetId: {}", datasetId);
-
    }

    /**
@@ -760,9 +606,9 @@ public class KnowledgeBaseServiceImpl extends BaseServiceImpl<KnowledgeBaseDao,
    }

    /**
-     * 从RAGFlow API获取知识库的文档数量
+     * 从适配器获取知识库的文档数量
     */
-    private Integer getDocumentCountFromRAGFlow(String datasetId, String ragModelId) {
+    private Integer getDocumentCountFromRAG(String datasetId, String ragModelId) {
        if (StringUtils.isBlank(datasetId) || StringUtils.isBlank(ragModelId)) {
            log.warn("datasetId或ragModelId为空，无法获取文档数量");
            return 0;
@@ -770,79 +616,29 @@ public class KnowledgeBaseServiceImpl extends BaseServiceImpl<KnowledgeBaseDao,

        log.info("开始获取知识库 {} 的文档数量", datasetId);

-        // 获取RAG配置
-        Map<String, Object> ragConfig = getValidatedRAGConfig(ragModelId);
-        String baseUrl = (String) ragConfig.get("base_url");
-        String apiKey = (String) ragConfig.get("api_key");
-
-        // 构建请求URL - 调用RAGFlow API获取文档列表，但不返回文档详情，只获取总数
-        String url = baseUrl + "/api/v1/datasets/" + datasetId + "/documents?page=1&size=1";
-        log.debug("请求URL: {}", url);
-
-        // 设置请求头
-        HttpHeaders headers = new HttpHeaders();
-        headers.setContentType(MediaType.APPLICATION_JSON);
-        headers.set("Authorization", "Bearer " + apiKey);
-
-        HttpEntity<String> requestEntity = new HttpEntity<>(headers);
-
-        // 发送GET请求
-        log.info("发送GET请求到RAGFlow API获取文档数量...");
-        ResponseEntity<String> response;
        try {
-            response = restTemplate.exchange(url, HttpMethod.GET, requestEntity, String.class);
+            // 获取RAG配置
+            Map<String, Object> ragConfig = getValidatedRAGConfig(ragModelId);
+
+            // 从RAG配置中提取适配器类型
+            String adapterType = extractAdapterType(ragConfig);
+
+            // 使用适配器工厂获取适配器实例
+            KnowledgeBaseAdapter adapter = KnowledgeBaseAdapterFactory.getAdapter(adapterType, ragConfig);
+
+            // 调用适配器的获取文档数量方法
+            Integer documentCount = adapter.getDocumentCount(datasetId);
+
+            log.info("获取知识库 {} 的文档数量成功: {}", datasetId, documentCount);
+            return documentCount;
+
        } catch (Exception e) {
-            String errorMessage = url + e.getMessage();
+            // 构建详细的错误信息，包含异常类型和消息
+            String baseErrorMessage = e.getClass().getSimpleName() + " - 获取知识库文档数量失败";
+            String errorMessage = baseErrorMessage + (e.getMessage() != null ? ": " + e.getMessage() : "");
            log.error(errorMessage, e);
            return 0;
        }
-
-        log.info("RAGFlow API响应状态码: {}", response.getStatusCode());
-
-        if (!response.getStatusCode().is2xxSuccessful()) {
-            log.error("RAGFlow API调用失败，状态码: {}, 响应内容: {}", response.getStatusCode(), response.getBody());
-            return 0;
-        }
-
-        String responseBody = response.getBody();
-        log.debug("RAGFlow API响应内容: {}", responseBody);
-
-        // 解析响应
-        try {
-            ObjectMapper objectMapper = new ObjectMapper();
-            Map<String, Object> responseMap = objectMapper.readValue(responseBody, Map.class);
-            Integer code = (Integer) responseMap.get("code");
-
-            if (code != null && code == 0) {
-                Object dataObj = responseMap.get("data");
-                if (dataObj instanceof Map) {
-                    Map<String, Object> dataMap = (Map<String, Object>) dataObj;
-                    Object totalObj = dataMap.get("total");
-                    if (totalObj instanceof Integer) {
-                        Integer documentCount = (Integer) totalObj;
-                        log.info("获取知识库 {} 的文档数量成功: {}", datasetId, documentCount);
-                        return documentCount;
-                    } else if (totalObj instanceof Long) {
-                        Long documentCount = (Long) totalObj;
-                        log.info("获取知识库 {} 的文档数量成功: {}", datasetId, documentCount);
-                        return documentCount.intValue();
-                    }
-                }
-            } else {
-                log.error("RAGFlow API调用失败，响应码: {}, 响应内容: {}", code, responseBody);
-            }
-        } catch (IOException e) {
-            // 构建详细的错误信息，包含异常类型和消息
-            String baseErrorMessage = e.getClass().getSimpleName() + " - 解析RAGFlow API响应时发生IO异常";
-            String errorMessage = baseErrorMessage + (e.getMessage() != null ? ": " + e.getMessage() : "");
-            log.error(errorMessage, e);
-        } catch (Exception e) {
-            // 构建详细的错误信息，包含异常类型和消息
-            String baseErrorMessage = e.getClass().getSimpleName() + " - 解析RAGFlow API响应失败";
-            String errorMessage = baseErrorMessage + (e.getMessage() != null ? ": " + e.getMessage() : "");
-            log.error(errorMessage, e);
-        }
-        return 0;
    }

 }
@@ -0,0 +1,70 @@
+package xiaozhi.modules.llm.service;
+
+/**
+ * LLM服务接口
+ * 支持多种大模型调用
+ */
+public interface LLMService {
+
+    /**
+     * 生成聊天记录总结
+     * 
+     * @param conversation   对话内容
+     * @param promptTemplate 提示词模板
+     * @return 总结结果
+     */
+    String generateSummary(String conversation, String promptTemplate);
+
+    /**
+     * 生成聊天记录总结（使用默认提示词）
+     * 
+     * @param conversation 对话内容
+     * @return 总结结果
+     */
+    String generateSummary(String conversation);
+
+    /**
+     * 生成聊天记录总结（指定模型ID）
+     * 
+     * @param conversation 对话内容
+     * @param modelId      模型ID
+     * @return 总结结果
+     */
+    String generateSummaryWithModel(String conversation, String modelId);
+
+    /**
+     * 生成聊天记录总结（指定模型ID和提示词模板）
+     * 
+     * @param conversation   对话内容
+     * @param promptTemplate 提示词模板
+     * @param modelId        模型ID
+     * @return 总结结果
+     */
+    String generateSummary(String conversation, String promptTemplate, String modelId);
+
+    /**
+     * 生成聊天记录总结（包含历史记忆合并）
+     * 
+     * @param conversation   对话内容
+     * @param historyMemory  历史记忆
+     * @param promptTemplate 提示词模板
+     * @param modelId        模型ID
+     * @return 总结结果
+     */
+    String generateSummaryWithHistory(String conversation, String historyMemory, String promptTemplate, String modelId);
+
+    /**
+     * 检查服务是否可用
+     * 
+     * @return 是否可用
+     */
+    boolean isAvailable();
+
+    /**
+     * 检查指定模型的服务是否可用
+     * 
+     * @param modelId 模型ID
+     * @return 是否可用
+     */
+    boolean isAvailable(String modelId);
+}
@@ -0,0 +1,305 @@
+package xiaozhi.modules.llm.service.impl;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Service;
+import org.springframework.web.client.RestTemplate;
+
+import cn.hutool.json.JSONArray;
+import cn.hutool.json.JSONObject;
+import cn.hutool.json.JSONUtil;
+import lombok.extern.slf4j.Slf4j;
+import xiaozhi.modules.llm.service.LLMService;
+import xiaozhi.modules.model.entity.ModelConfigEntity;
+import xiaozhi.modules.model.service.ModelConfigService;
+
+/**
+ * OpenAI风格API的LLM服务实现
+ * 支持阿里云、DeepSeek、ChatGLM等兼容OpenAI API的模型
+ */
+@Slf4j
+@Service
+public class OpenAIStyleLLMServiceImpl implements LLMService {
+
+    @Autowired
+    private ModelConfigService modelConfigService;
+
+    private final RestTemplate restTemplate = new RestTemplate();
+
+    private static final String DEFAULT_SUMMARY_PROMPT = "你是一个经验丰富的记忆总结者，擅长将对话内容进行总结摘要，遵循以下规则：\n1、总结用户的重要信息，以便在未来的对话中提供更个性化的服务\n2、不要重复总结，不要遗忘之前记忆，除非原来的记忆超过了1800字，否则不要遗忘、不要压缩用户的历史记忆\n3、用户操控的设备音量、播放音乐、天气、退出、不想对话等和用户本身无关的内容，这些信息不需要加入到总结中\n4、聊天内容中的今天的日期时间、今天的天气情况与用户事件无关的数据，这些信息如果当成记忆存储会影响后续对话，这些信息不需要加入到总结中\n5、不要把设备操控的成果结果和失败结果加入到总结中，也不要把用户的一些废话加入到总结中\n6、不要为了总结而总结，如果用户的聊天没有意义，请返回原来的历史记录也是可以的\n7、只需要返回总结摘要，严格控制在1800字内\n8、不要包含代码、xml，不需要解释、注释和说明，保存记忆时仅从对话提取信息，不要混入示例内容\n9、如果提供了历史记忆，请将新对话内容与历史记忆进行智能合并，保留有价值的历史信息，同时添加新的重要信息\n\n历史记忆：\n{history_memory}\n\n新对话内容：\n{conversation}";
+
+    @Override
+    public String generateSummary(String conversation) {
+        return generateSummary(conversation, null, null);
+    }
+
+    @Override
+    public String generateSummaryWithModel(String conversation, String modelId) {
+        return generateSummary(conversation, null, modelId);
+    }
+
+    @Override
+    public String generateSummary(String conversation, String promptTemplate, String modelId) {
+        if (!isAvailable()) {
+            log.warn("LLM服务不可用，无法生成总结");
+            return "LLM服务不可用，无法生成总结";
+        }
+
+        try {
+            // 从智控台获取LLM模型配置
+            ModelConfigEntity llmConfig;
+            if (modelId != null && !modelId.trim().isEmpty()) {
+                // 通过具体模型ID获取配置
+                llmConfig = modelConfigService.getModelByIdFromCache(modelId);
+            } else {
+                // 保持向后兼容，使用默认配置
+                llmConfig = getDefaultLLMConfig();
+            }
+
+            if (llmConfig == null || llmConfig.getConfigJson() == null) {
+                log.error("未找到可用的LLM模型配置，modelId: {}", modelId);
+                return "未找到可用的LLM模型配置";
+            }
+
+            JSONObject configJson = llmConfig.getConfigJson();
+            String baseUrl = configJson.getStr("base_url");
+            String model = configJson.getStr("model_name");
+            String apiKey = configJson.getStr("api_key");
+            Double temperature = configJson.getDouble("temperature");
+            Integer maxTokens = configJson.getInt("max_tokens");
+
+            if (StringUtils.isBlank(baseUrl) || StringUtils.isBlank(apiKey)) {
+                log.error("LLM配置不完整，baseUrl或apiKey为空");
+                return "LLM配置不完整，无法生成总结";
+            }
+
+            // 构建提示词
+            String prompt = (promptTemplate != null ? promptTemplate : DEFAULT_SUMMARY_PROMPT).replace("{conversation}",
+                    conversation);
+
+            // 构建请求体
+            Map<String, Object> requestBody = new HashMap<>();
+            requestBody.put("model", model != null ? model : "gpt-3.5-turbo");
+
+            Map<String, Object>[] messages = new Map[1];
+            Map<String, Object> message = new HashMap<>();
+            message.put("role", "user");
+            message.put("content", prompt);
+            messages[0] = message;
+
+            requestBody.put("messages", messages);
+            requestBody.put("temperature", temperature != null ? temperature : 0.7);
+            requestBody.put("max_tokens", maxTokens != null ? maxTokens : 2000);
+
+            // 发送HTTP请求
+            HttpHeaders headers = new HttpHeaders();
+            headers.setContentType(MediaType.APPLICATION_JSON);
+            headers.set("Authorization", "Bearer " + apiKey);
+
+            HttpEntity<Map<String, Object>> entity = new HttpEntity<>(requestBody, headers);
+
+            // 构建完整的API URL
+            String apiUrl = baseUrl;
+            if (!apiUrl.endsWith("/chat/completions")) {
+                if (!apiUrl.endsWith("/")) {
+                    apiUrl += "/";
+                }
+                apiUrl += "chat/completions";
+            }
+
+            ResponseEntity<String> response = restTemplate.exchange(
+                    apiUrl, HttpMethod.POST, entity, String.class);
+
+            if (response.getStatusCode().is2xxSuccessful()) {
+                JSONObject responseJson = JSONUtil.parseObj(response.getBody());
+                JSONArray choices = responseJson.getJSONArray("choices");
+                if (choices != null && choices.size() > 0) {
+                    JSONObject choice = choices.getJSONObject(0);
+                    JSONObject messageObj = choice.getJSONObject("message");
+                    return messageObj.getStr("content");
+                }
+            } else {
+                log.error("LLM API调用失败，状态码：{}，响应：{}", response.getStatusCode(), response.getBody());
+            }
+        } catch (Exception e) {
+            log.error("调用LLM服务生成总结时发生异常，modelId: {}", modelId, e);
+        }
+
+        return "生成总结失败，请稍后重试";
+    }
+
+    @Override
+    public String generateSummary(String conversation, String promptTemplate) {
+        return generateSummary(conversation, promptTemplate, null);
+    }
+
+    @Override
+    public String generateSummaryWithHistory(String conversation, String historyMemory, String promptTemplate,
+            String modelId) {
+        if (!isAvailable()) {
+            log.warn("LLM服务不可用，无法生成总结");
+            return "LLM服务不可用，无法生成总结";
+        }
+
+        try {
+            // 从智控台获取LLM模型配置
+            ModelConfigEntity llmConfig;
+            if (modelId != null && !modelId.trim().isEmpty()) {
+                // 通过具体模型ID获取配置
+                llmConfig = modelConfigService.getModelByIdFromCache(modelId);
+            } else {
+                // 保持向后兼容，使用默认配置
+                llmConfig = getDefaultLLMConfig();
+            }
+
+            if (llmConfig == null || llmConfig.getConfigJson() == null) {
+                log.error("未找到可用的LLM模型配置，modelId: {}", modelId);
+                return "未找到可用的LLM模型配置";
+            }
+
+            JSONObject configJson = llmConfig.getConfigJson();
+            String baseUrl = configJson.getStr("base_url");
+            String model = configJson.getStr("model_name");
+            String apiKey = configJson.getStr("api_key");
+
+            if (StringUtils.isBlank(baseUrl) || StringUtils.isBlank(apiKey)) {
+                log.error("LLM配置不完整，baseUrl或apiKey为空");
+                return "LLM配置不完整，无法生成总结";
+            }
+
+            // 构建提示词，包含历史记忆
+            String prompt = (promptTemplate != null ? promptTemplate : DEFAULT_SUMMARY_PROMPT)
+                    .replace("{history_memory}", historyMemory != null ? historyMemory : "无历史记忆")
+                    .replace("{conversation}", conversation);
+
+            // 构建请求体
+            Map<String, Object> requestBody = new HashMap<>();
+            requestBody.put("model", model != null ? model : "gpt-3.5-turbo");
+
+            Map<String, Object>[] messages = new Map[1];
+            Map<String, Object> message = new HashMap<>();
+            message.put("role", "user");
+            message.put("content", prompt);
+            messages[0] = message;
+
+            requestBody.put("messages", messages);
+            requestBody.put("temperature", 0.2);
+            requestBody.put("max_tokens", 2000);
+
+            // 发送HTTP请求
+            HttpHeaders headers = new HttpHeaders();
+            headers.setContentType(MediaType.APPLICATION_JSON);
+            headers.set("Authorization", "Bearer " + apiKey);
+
+            HttpEntity<Map<String, Object>> entity = new HttpEntity<>(requestBody, headers);
+
+            // 构建完整的API URL
+            String apiUrl = baseUrl;
+            if (!apiUrl.endsWith("/chat/completions")) {
+                if (!apiUrl.endsWith("/")) {
+                    apiUrl += "/";
+                }
+                apiUrl += "chat/completions";
+            }
+
+            ResponseEntity<String> response = restTemplate.exchange(
+                    apiUrl, HttpMethod.POST, entity, String.class);
+
+            if (response.getStatusCode().is2xxSuccessful()) {
+                JSONObject responseJson = JSONUtil.parseObj(response.getBody());
+                JSONArray choices = responseJson.getJSONArray("choices");
+                if (choices != null && choices.size() > 0) {
+                    JSONObject choice = choices.getJSONObject(0);
+                    JSONObject messageObj = choice.getJSONObject("message");
+                    return messageObj.getStr("content");
+                }
+            } else {
+                log.error("LLM API调用失败，状态码：{}，响应：{}", response.getStatusCode(), response.getBody());
+            }
+        } catch (Exception e) {
+            log.error("调用LLM服务生成总结时发生异常，modelId: {}", modelId, e);
+        }
+
+        return "生成总结失败，请稍后重试";
+    }
+
+    @Override
+    public boolean isAvailable() {
+        try {
+            ModelConfigEntity defaultLLMConfig = getDefaultLLMConfig();
+            if (defaultLLMConfig == null || defaultLLMConfig.getConfigJson() == null) {
+                return false;
+            }
+
+            JSONObject configJson = defaultLLMConfig.getConfigJson();
+            String baseUrl = configJson.getStr("base_url");
+            String apiKey = configJson.getStr("api_key");
+
+            return baseUrl != null && !baseUrl.trim().isEmpty() &&
+                    apiKey != null && !apiKey.trim().isEmpty();
+        } catch (Exception e) {
+            log.error("检查LLM服务可用性时发生异常：", e);
+            return false;
+        }
+    }
+
+    @Override
+    public boolean isAvailable(String modelId) {
+        try {
+            if (modelId == null || modelId.trim().isEmpty()) {
+                return isAvailable();
+            }
+
+            // 通过具体模型ID获取配置
+            ModelConfigEntity modelConfig = modelConfigService.getModelByIdFromCache(modelId);
+            if (modelConfig == null || modelConfig.getConfigJson() == null) {
+                log.warn("未找到指定的LLM模型配置，modelId: {}", modelId);
+                return false;
+            }
+
+            JSONObject configJson = modelConfig.getConfigJson();
+            String baseUrl = configJson.getStr("base_url");
+            String apiKey = configJson.getStr("api_key");
+
+            return baseUrl != null && !baseUrl.trim().isEmpty() &&
+                    apiKey != null && !apiKey.trim().isEmpty();
+        } catch (Exception e) {
+            log.error("检查LLM服务可用性时发生异常，modelId: {}", modelId, e);
+            return false;
+        }
+    }
+
+    /**
+     * 从智控台获取默认的LLM模型配置
+     */
+    private ModelConfigEntity getDefaultLLMConfig() {
+        try {
+            // 获取所有启用的LLM模型配置
+            List<ModelConfigEntity> llmConfigs = modelConfigService.getEnabledModelsByType("LLM");
+            if (llmConfigs == null || llmConfigs.isEmpty()) {
+                return null;
+            }
+
+            // 优先返回默认配置，如果没有默认配置则返回第一个启用的配置
+            for (ModelConfigEntity config : llmConfigs) {
+                if (config.getIsDefault() != null && config.getIsDefault() == 1) {
+                    return config;
+                }
+            }
+
+            return llmConfigs.get(0);
+        } catch (Exception e) {
+            log.error("获取LLM模型配置时发生异常：", e);
+            return null;
+        }
+    }
+}
@@ -55,4 +55,12 @@ public interface ModelConfigService extends BaseService<ModelConfigEntity> {
     * @return TTS平台列表(id和modelName)
     */
    List<Map<String, Object>> getTtsPlatformList();
+
+    /**
+     * 根据模型类型获取所有启用的模型配置
+     *
+     * @param modelType 模型类型（如：LLM, TTS, ASR等）
+     * @return 启用的模型配置列表
+     */
+    List<ModelConfigEntity> getEnabledModelsByType(String modelType);
 }
@@ -502,4 +502,22 @@ public class ModelConfigServiceImpl extends BaseServiceImpl<ModelConfigDao, Mode
    public List<Map<String, Object>> getTtsPlatformList() {
        return modelConfigDao.getTtsPlatformList();
    }
+
+    /**
+     * 根据模型类型获取所有启用的模型配置
+     */
+    @Override
+    public List<ModelConfigEntity> getEnabledModelsByType(String modelType) {
+        if (StringUtils.isBlank(modelType)) {
+            return null;
+        }
+
+        List<ModelConfigEntity> entities = modelConfigDao.selectList(
+                new QueryWrapper<ModelConfigEntity>()
+                        .eq("model_type", modelType)
+                        .eq("is_enabled", 1)
+                        .orderByAsc("sort"));
+
+        return entities;
+    }
 }
@@ -89,7 +89,7 @@ public class ShiroConfig {
        filterMap.put("/config/**", "server");
        filterMap.put("/agent/chat-history/report", "server");
        filterMap.put("/agent/chat-history/download/**", "anon");
-        filterMap.put("/agent/saveMemory/**", "server");
+        filterMap.put("/agent/chat-summary/**", "server");
        filterMap.put("/agent/play/**", "anon");
        filterMap.put("/voiceClone/play/**", "anon");
        filterMap.put("/**", "oauth2");
@@ -6,6 +6,7 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

+import org.apache.commons.lang3.StringUtils;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.PutMapping;
@@ -23,7 +24,9 @@ import xiaozhi.common.exception.ErrorCode;
 import xiaozhi.common.exception.RenException;
 import xiaozhi.common.page.TokenDTO;
 import xiaozhi.common.user.UserDetail;
+import xiaozhi.common.utils.JsonUtils;
 import xiaozhi.common.utils.Result;
+import xiaozhi.common.utils.Sm2DecryptUtil;
 import xiaozhi.common.validator.AssertUtils;
 import xiaozhi.common.validator.ValidatorUtils;
 import xiaozhi.modules.security.dto.LoginDTO;
@@ -32,8 +35,6 @@ import xiaozhi.modules.security.password.PasswordUtils;
 import xiaozhi.modules.security.service.CaptchaService;
 import xiaozhi.modules.security.service.SysUserTokenService;
 import xiaozhi.modules.security.user.SecurityUser;
-import xiaozhi.common.utils.Sm2DecryptUtil;
-import org.apache.commons.lang3.StringUtils;
 import xiaozhi.modules.sys.dto.PasswordDTO;
 import xiaozhi.modules.sys.dto.RetrievePasswordDTO;
 import xiaozhi.modules.sys.dto.SysUserDTO;
@@ -89,13 +90,13 @@ public class LoginController {
    @Operation(summary = "登录")
    public Result<TokenDTO> login(@RequestBody LoginDTO login) {
        String password = login.getPassword();
-        
+
        // 使用工具类解密并验证验证码
        String actualPassword = Sm2DecryptUtil.decryptAndValidateCaptcha(
                password, login.getCaptchaId(), captchaService, sysParamsService);
-        
+
        login.setPassword(actualPassword);
-        
+
        // 按照用户名获取用户
        SysUserDTO userDTO = sysUserService.getByUsername(login.getUsername());
        // 判断用户是否存在
@@ -108,8 +109,6 @@ public class LoginController {
        }
        return sysUserTokenService.createToken(userDTO.getId());
    }
-    
-

    @PostMapping("/register")
    @Operation(summary = "注册")
@@ -117,15 +116,15 @@ public class LoginController {
        if (!sysUserService.getAllowUserRegister()) {
            throw new RenException(ErrorCode.USER_REGISTER_DISABLED);
        }
-        
+
        String password = login.getPassword();
-        
+
        // 使用工具类解密并验证验证码
        String actualPassword = Sm2DecryptUtil.decryptAndValidateCaptcha(
                password, login.getCaptchaId(), captchaService, sysParamsService);
-        
+
        login.setPassword(actualPassword);
-        
+
        // 是否开启手机注册
        Boolean isMobileRegister = sysParamsService
                .getValueObject(Constant.SysMSMParam.SERVER_ENABLE_MOBILE_REGISTER.getValue(), Boolean.class);
@@ -204,11 +203,11 @@ public class LoginController {
        }

        String password = dto.getPassword();
-        
+
        // 使用工具类解密并验证验证码
        String actualPassword = Sm2DecryptUtil.decryptAndValidateCaptcha(
                password, dto.getCaptchaId(), captchaService, sysParamsService);
-        
+
        dto.setPassword(actualPassword);

        sysUserService.changePasswordDirectly(userDTO.getId(), dto.getPassword());
@@ -229,7 +228,7 @@ public class LoginController {
        config.put("beianIcpNum", sysParamsService.getValue(Constant.SysBaseParam.BEIAN_ICP_NUM.getValue(), true));
        config.put("beianGaNum", sysParamsService.getValue(Constant.SysBaseParam.BEIAN_GA_NUM.getValue(), true));
        config.put("name", sysParamsService.getValue(Constant.SysBaseParam.SERVER_NAME.getValue(), true));
-        
+
        // SM2公钥
        String publicKey = sysParamsService.getValue(Constant.SM2_PUBLIC_KEY, true);
        if (StringUtils.isBlank(publicKey)) {
@@ -237,6 +236,12 @@ public class LoginController {
        }
        config.put("sm2PublicKey", publicKey);

+        // 获取system-web.menu参数配置
+        String menuConfig = sysParamsService.getValue("system-web.menu", true);
+        if (StringUtils.isNotBlank(menuConfig)) {
+            config.put("systemWebMenu", JsonUtils.parseObject(menuConfig, Object.class));
+        }
+
        return new Result<Map<String, Object>>().ok(config);
    }
 }
@@ -31,6 +31,8 @@ import xiaozhi.modules.sys.dto.ServerActionResponseDTO;
 import xiaozhi.modules.sys.enums.ServerActionEnum;
 import xiaozhi.modules.sys.service.SysParamsService;
 import xiaozhi.modules.sys.utils.WebSocketClientManager;
+import xiaozhi.modules.device.service.DeviceService;
+import xiaozhi.common.redis.RedisUtils;

 /**
 * 服务端管理控制器
@@ -41,6 +43,8 @@ import xiaozhi.modules.sys.utils.WebSocketClientManager;
@AllArgsConstructor
 public class ServerSideManageController {
    private final SysParamsService sysParamsService;
+    private final DeviceService deviceService;
+    private final RedisUtils redisUtils;
    private static final ObjectMapper objectMapper;
    static {
        objectMapper = new ObjectMapper();
@@ -85,9 +89,22 @@ public class ServerSideManageController {
            return false;
        }
        String serverSK = sysParamsService.getValue(Constant.SERVER_SECRET, true);
+
+        String deviceId = UUID.randomUUID().toString();
+        String clientId = UUID.randomUUID().toString();
+
+        String redisKey = xiaozhi.common.redis.RedisKeys.getTmpRegisterMacKey(deviceId);
+        redisUtils.set(redisKey, "true", 300); // 5分钟有效期
+
        WebSocketHttpHeaders headers = new WebSocketHttpHeaders();
-        headers.add("device-id", UUID.randomUUID().toString());
-        headers.add("client-id", UUID.randomUUID().toString());
+        headers.add("device-id", deviceId);
+        headers.add("client-id", clientId);
+        try {
+            String token = deviceService.generateWebSocketToken(clientId, deviceId);
+            headers.add("authorization", "Bearer " + token);
+        } catch (Exception e) {
+            throw new RenException(ErrorCode.WEB_SOCKET_CONNECT_FAILED);
+        }

        try (WebSocketClientManager client = new WebSocketClientManager.Builder()
                .connectTimeout(3, TimeUnit.SECONDS)
@@ -174,7 +174,7 @@ public class SysParamsController {
            return;
        }
        if (StringUtils.isBlank(url) || url.equals("null")) {
-            throw new RenException(ErrorCode.OTA_URL_EMPTY);
+            return;
        }

        // 检查是否包含localhost或127.0.0.1
@@ -211,7 +211,7 @@ public class SysParamsController {
            return;
        }
        if (StringUtils.isBlank(url) || url.equals("null")) {
-            throw new RenException(ErrorCode.MCP_URL_EMPTY);
+            return;
        }
        if (url.contains("localhost") || url.contains("127.0.0.1")) {
            throw new RenException(ErrorCode.MCP_URL_LOCALHOST);
@@ -242,7 +242,7 @@ public class SysParamsController {
            return;
        }
        if (StringUtils.isBlank(url) || url.equals("null")) {
-            throw new RenException(ErrorCode.VOICEPRINT_URL_EMPTY);
+            return;
        }
        if (url.contains("localhost") || url.contains("127.0.0.1")) {
            throw new RenException(ErrorCode.VOICEPRINT_URL_LOCALHOST);
@@ -0,0 +1,17 @@
+-- 更新HuoshanDoubleStreamTTS供应器配置，增加开启链接复用选项
+UPDATE `ai_model_provider`
+SET fields = '[{"key": "ws_url", "type": "string", "label": "WebSocket地址"}, {"key": "appid", "type": "string", "label": "应用ID"}, {"key": "access_token", "type": "string", "label": "访问令牌"}, {"key": "resource_id", "type": "string", "label": "资源ID"}, {"key": "speaker", "type": "string", "label": "默认音色"}, {"key": "enable_ws_reuse", "type": "boolean", "label": "是否开启链接复用", "default": true}, {"key": "speech_rate", "type": "number", "label": "语速(-50~100)"}, {"key": "loudness_rate", "type": "number", "label": "音量(-50~100)"}, {"key": "pitch", "type": "number", "label": "音高(-12~12)"}]'
+WHERE id = 'SYSTEM_TTS_HSDSTTS';
+
+UPDATE `ai_model_config` SET 
+`doc_link` = 'https://console.volcengine.com/speech/service/10007',
+`remark` = '火山引擎语音合成服务配置说明：
+1. 访问 https://www.volcengine.com/ 注册并开通火山引擎账号
+2. 访问 https://console.volcengine.com/speech/service/10007 开通语音合成大模型，购买音色
+3. 在页面底部获取appid和access_token
+5. 资源ID固定为：volc.service_type.10029（大模型语音合成及混音）
+6. 链接复用：开启WebSocket连接复用，默认true减少链接损耗（注意：复用后设备处于聆听状态时空闲链接会占并发数）
+7. 语速：-50~100，可不填，正常默认值0，可填-50~100
+8. 音量：-50~100，可不填，正常默认值0，可填-50~100
+9. 音高：-12~12，可不填，正常默认值0，可填-12~12
+10. 填入配置文件中' WHERE `id` = 'TTS_HuoshanDoubleStreamTTS';
@@ -0,0 +1,6 @@
+-- 添加系统功能菜单配置参数
+delete from `sys_params` where param_code = 'system-web.menu';
+
+-- 添加系统功能菜单配置参数
+INSERT INTO `sys_params` (id, param_code, param_value, value_type, param_type, remark) VALUES 
+(600, 'system-web.menu', '{"features":{"voiceprintRecognition":{"name":"feature.voiceprintRecognition.name","enabled":false,"description":"feature.voiceprintRecognition.description"},"voiceClone":{"name":"feature.voiceClone.name","enabled":false,"description":"feature.voiceClone.description"},"knowledgeBase":{"name":"feature.knowledgeBase.name","enabled":false,"description":"feature.knowledgeBase.description"},"mcpAccessPoint":{"name":"feature.mcpAccessPoint.name","enabled":false,"description":"feature.mcpAccessPoint.description"},"vad":{"name":"feature.vad.name","enabled":true,"description":"feature.vad.description"},"asr":{"name":"feature.asr.name","enabled":true,"description":"feature.asr.description"}},"groups":{"featureManagement":["voiceprintRecognition","voiceClone","knowledgeBase","mcpAccessPoint"],"voiceManagement":["vad","asr"]}}', 'json', 1, '系统功能菜单配置');
@@ -0,0 +1,14 @@
+-- liquibase formatted sql
+
+-- changeset xiaozhi:202512041515
+CREATE TABLE ai_agent_context_provider (
+    id VARCHAR(32) NOT NULL COMMENT '主键',
+    agent_id VARCHAR(32) NOT NULL COMMENT '智能体ID',
+    context_providers JSON COMMENT '上下文源配置',
+    creator BIGINT COMMENT '创建者',
+    created_at DATETIME COMMENT '创建时间',
+    updater BIGINT COMMENT '更新者',
+    updated_at DATETIME COMMENT '更新时间',
+    PRIMARY KEY (id),
+    INDEX idx_agent_id (agent_id)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='智能体上下文源配置表';
@@ -0,0 +1,6 @@
+-- 删除server模块是否开启token认证参数
+delete from `sys_params` where param_code = 'server.auth.enabled';
+
+-- 添加server模块是否开启token认证参数
+INSERT INTO `sys_params` (id, param_code, param_value, value_type, param_type, remark) VALUES 
+(122, 'server.auth.enabled', 'true', 'boolean', 1, 'server模块是否开启token认证');
@@ -0,0 +1 @@
+INSERT INTO `sys_params` (id, param_code, param_value, value_type, param_type, remark) VALUES (311, 'enable_websocket_ping', 'false', 'boolean', 1, '是否启用WebSocket心跳保活机制');
@@ -0,0 +1,2 @@
+-- 为智能体聊天历史记录添加音频ID索引
+ALTER TABLE ai_agent_chat_history ADD INDEX idx_ai_agent_chat_history_audio_id (audio_id);
@@ -0,0 +1,10 @@
+-- 更新豆包流式ASR供应器，增加end_window_size配置
+delete from `ai_model_provider` where id = 'SYSTEM_ASR_DoubaoStreamASR';
+INSERT INTO `ai_model_provider` (`id`, `model_type`, `provider_code`, `name`, `fields`, `sort`, `creator`, `create_date`, `updater`, `update_date`) VALUES
+('SYSTEM_ASR_DoubaoStreamASR', 'ASR', 'doubao_stream', '火山引擎语音识别(流式)', '[{"key":"appid","label":"应用ID","type":"string"},{"key":"access_token","label":"访问令牌","type":"string"},{"key":"cluster","label":"集群","type":"string"},{"key":"boosting_table_name","label":"热词文件名称","type":"string"},{"key":"correct_table_name","label":"替换词文件名称","type":"string"},{"key":"output_dir","label":"输出目录","type":"string"},{"key":"end_window_size","label":"静音判定时长(ms)","type":"number"}]', 3, 1, NOW(), 1, NOW());
+
+
+-- 更新豆包流式ASR模型配置，增加end_window_size默认值
+UPDATE `ai_model_config` SET
+`config_json` = JSON_SET(`config_json`, '$.end_window_size', 200)
+WHERE `id` = 'ASR_DoubaoStreamASR' AND JSON_EXTRACT(`config_json`, '$.end_window_size') IS NULL;
@@ -423,3 +423,53 @@ databaseChangeLog:
        - sqlFile:
            encoding: utf8
            path: classpath:db/changelog/202511131023.sql
+  - changeSet:
+      id: 202511221450
+      author: RanChen
+      changes:
+        - sqlFile:
+            encoding: utf8
+            path: classpath:db/changelog/202511221450.sql
+  - changeSet:         
+      id: 202512031517
+      author: rainv123
+      changes:
+        - sqlFile:
+            encoding: utf8
+            path: classpath:db/changelog/202512031517.sql
+    
+  - changeSet:
+      id: 202512041515
+      author: cgd
+      changes:
+        - sqlFile:
+            encoding: utf8
+            path: classpath:db/changelog/202512041515.sql
+  - changeSet:
+      id: 202512131453
+      author: hrz
+      changes:
+        - sqlFile:
+            encoding: utf8
+            path: classpath:db/changelog/202512131453.sql
+  - changeSet:
+      id: 202512161529
+      author: RanChen
+      changes:
+        - sqlFile:
+            encoding: utf8
+            path: classpath:db/changelog/202512161529.sql
+  - changeSet:
+      id: 202512192245
+      author: hrz
+      changes:
+        - sqlFile:
+            encoding: utf8
+            path: classpath:db/changelog/202512192245.sql
+  - changeSet:
+      id: 202512221117
+      author: RanChen
+      changes:
+        - sqlFile:
+            encoding: utf8
+            path: classpath:db/changelog/202512221117.sql
@@ -189,4 +189,13 @@
 10180=\u6587\u4EF6\u5185\u5BB9\u4E0D\u80FD\u4E3A\u7A7A
 10181=\u97F3\u8272\u514B\u9686\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A
 10182=\u97F3\u8272\u514B\u9686\u97F3\u9891\u4E0D\u5B58\u5728
-10183=\u9ED8\u8BA4\u667A\u80FD\u4F53\u672A\u627E\u5230
+10183=\u9ED8\u8BA4\u667A\u80FD\u4F53\u672A\u627E\u5230
+10184=\u4E0D\u652F\u6301\u7684\u9002\u914D\u5668\u7C7B\u578B
+10185=RAG\u914D\u7F6E\u9A8C\u8BC1\u5931\u8D25
+10186=\u9002\u914D\u5668\u521B\u5EFA\u5931\u8D25
+10187=\u9002\u914D\u5668\u521D\u59CB\u5316\u5931\u8D25
+10188=\u9002\u914D\u5668\u8FDE\u63A5\u6D4B\u8BD5\u5931\u8D25
+10189=\u9002\u914D\u5668\u64CD\u4F5C\u5931\u8D25
+10190=\u9002\u914D\u5668\u672A\u627E\u5230
+10191=\u9002\u914D\u5668\u7F13\u5B58\u9519\u8BEF
+10192=\u9002\u914D\u5668\u7C7B\u578B\u672A\u627E\u5230
@@ -189,4 +189,13 @@
 10180=Dateiinhalt darf nicht leer sein
 10181=Stimmenklon-Name darf nicht leer sein
 10182=Stimmenklon-Audio nicht gefunden
-10183=Standard-Agent-Vorlage nicht gefunden
+10183=Standard-Agent-Vorlage nicht gefunden
+10184=Nicht unterstützter Adaptertyp
+10185=RAG-Konfigurationsvalidierung fehlgeschlagen
+10186=Adapter-Erstellung fehlgeschlagen
+10187=Adapter-Initialisierung fehlgeschlagen
+10188=Adapter-Verbindungstest fehlgeschlagen
+10189=Adapter-Operation fehlgeschlagen
+10190=Adapter nicht gefunden
+10191=Adapter-Cache-Fehler
+10192=Adaptertyp nicht gefunden
@@ -189,4 +189,13 @@
 10180=File content cannot be empty
 10181=Voice clone name cannot be empty
 10182=Voice clone audio not found
-10183=Default agent template not found
+10183=Default agent template not found
+10184=Unsupported adapter type
+10185=RAG configuration validation failed
+10186=Adapter creation failed
+10187=Adapter initialization failed
+10188=Adapter connection test failed
+10189=Adapter operation failed
+10190=Adapter not found
+10191=Adapter cache error
+10192=Adapter type not found
@@ -189,4 +189,13 @@
 10180=Nội dung tệp không thể để trống
 10181=Tên nhân bản giọng nói không thể để trống
 10182=Không tìm thấy âm thanh nhân bản giọng nói
-10183=Không tìm thấy mẫu agent mặc định
+10183=Không tìm thấy mẫu agent mặc định
+10184=Loại bộ chuyển đổi không được hỗ trợ
+10185=Kiểm tra cấu hình RAG thất bại
+10186=Tạo bộ chuyển đổi thất bại
+10187=Khởi tạo bộ chuyển đổi thất bại
+10188=Kiểm tra kết nối bộ chuyển đổi thất bại
+10189=Thao tác bộ chuyển đổi thất bại
+10190=Không tìm thấy bộ chuyển đổi
+10191=Lỗi bộ nhớ đệm bộ chuyển đổi
+10192=Không tìm thấy loại bộ chuyển đổi
@@ -189,4 +189,13 @@
 10180=\u6587\u4EF6\u5185\u5BB9\u4E0D\u80FD\u4E3A\u7A7A
 10181=\u97F3\u8272\u514B\u9686\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A
 10182=\u97F3\u8272\u514B\u9686\u97F3\u9891\u4E0D\u5B58\u5728
-10183=\u9ED8\u8BA4\u667A\u80FD\u4F53\u672A\u627E\u5230
+10183=\u9ED8\u8BA4\u667A\u80FD\u4F53\u672A\u627E\u5230
+10184=\u4E0D\u652F\u6301\u7684\u9002\u914D\u5668\u7C7B\u578B
+10185=RAG\u914D\u7F6E\u9A8C\u8BC1\u5931\u8D25
+10186=\u9002\u914D\u5668\u521B\u5EFA\u5931\u8D25
+10187=\u9002\u914D\u5668\u521D\u59CB\u5316\u5931\u8D25
+10188=\u9002\u914D\u5668\u8FDE\u63A5\u6D4B\u8BD5\u5931\u8D25
+10189=\u9002\u914D\u5668\u64CD\u4F5C\u5931\u8D25
+10190=\u9002\u914D\u5668\u672A\u627E\u5230
+10191=\u9002\u914D\u5668\u7F13\u5B58\u9519\u8BEF
+10192=\u9002\u914D\u5668\u7C7B\u578B\u672A\u627E\u5230
@@ -189,4 +189,13 @@
 10180=\u6587\u4ef6\u5185\u5bb9\u4e0d\u80fd\u70ba\u7a7a
 10181=\u97f3\u8272\u514b\u9686\u540d\u7a31\u4e0d\u80fd\u70ba\u7a7a
 10182=\u97f3\u8272\u514b\u9686\u97f3\u983b\u4e0d\u5b58\u5728
-10183=\u9ed8\u8ba4\u667a\u80fd\u4f53\u672a\u627e\u5230
+10183=\u9ed8\u8ba4\u667a\u80fd\u4f53\u672a\u627e\u5230
+10184=\u4E0D\u652F\u6301\u7684\u9002\u914D\u5668\u985E\u578B
+10185=RAG\u914D\u7F6E\u9A57\u8B49\u5931\u6557
+10186=\u9002\u914D\u5668\u5275\u5EFA\u5931\u6557
+10187=\u9002\u914D\u5668\u521D\u59CB\u5316\u5931\u6557
+10188=\u9002\u914D\u5668\u9023\u63A5\u6E2C\u8A66\u5931\u6557
+10189=\u9002\u914D\u5668\u64CD\u4F5C\u5931\u6557
+10190=\u9002\u914D\u5668\u672A\u627E\u5230
+10191=\u9002\u914D\u5668\u7F13\u5B58\u932F\u8AA4
+10192=\u9002\u914D\u5668\u985E\u578B\u672A\u627E\u5230
@@ -22,13 +22,18 @@
    created_at, updated_at
  </sql>

-  <delete id="deleteAudioByAgentId">
-    DELETE FROM ai_agent_chat_audio 
-    WHERE id IN (
-      SELECT audio_id 
-      FROM ai_agent_chat_history 
-      WHERE agent_id = #{agentId}
-    )
+  <select id="getAudioIdsByAgentId" resultType="java.lang.String">
+    SELECT DISTINCT audio_id
+    FROM ai_agent_chat_history
+    WHERE agent_id = #{agentId} AND audio_id IS NOT NULL
+  </select>
+
+  <delete id="deleteAudioByIds">
+    DELETE FROM ai_agent_chat_audio
+    WHERE id IN
+    <foreach collection="audioIds" item="id" open="(" separator="," close=")">
+      #{id}
+    </foreach>
  </delete>
  
  <update id="deleteAudioIdByAgentId">
@@ -235,7 +235,7 @@ function showAbout() {
    title: t('settings.aboutApp', { appName: import.meta.env.VITE_APP_TITLE }),
    content: t('settings.aboutContent', {
      appName: import.meta.env.VITE_APP_TITLE,
-      version: '0.8.8'
+      version: '0.8.10'
    }),
    showCancel: false,
    confirmText: t('common.confirm'),
@@ -200,6 +200,13 @@ export default {
    confirm() {
      this.saving = true;

+      // 校验模型ID不能为纯文字或空格
+      if (this.formData.id && !this.validateModelId(this.formData.id)) {
+        this.$message.error(this.$t('modelConfigDialog.invalidModelId'));
+        this.saving = false;
+        return;
+      }
+
      if (!this.formData.supplier) {
        this.$message.error(this.$t('addModelDialog.requiredSupplier'));
        this.saving = false;
@@ -254,6 +261,38 @@ export default {
      this.providerFields = [];
      this.currentProvider = null;
    },
+    
+    // 校验模型ID：不能为纯文字或空格
+    validateModelId(modelId) {
+      if (!modelId || typeof modelId !== 'string') {
+        return false;
+      }
+      
+      // 去除首尾空格
+      const trimmedId = modelId.trim();
+      
+      // 检查是否为空或纯空格
+      if (trimmedId === '') {
+        return false;
+      }
+      
+      // 检查是否只包含字母（纯文字）
+      if (/^[a-zA-Z]+$/.test(trimmedId)) {
+        return false;
+      }
+      
+      // 检查是否包含空格
+      if (/\s/.test(trimmedId)) {
+        return false;
+      }
+      
+      // 允许字母、数字、下划线、连字符
+      if (!/^[a-zA-Z0-9_-]+$/.test(trimmedId)) {
+        return false;
+      }
+      
+      return true;
+    }
  }
 }
 </script>
@@ -365,7 +404,7 @@ export default {

 .custom-input-bg .el-input__inner,
 .custom-input-bg .el-textarea__inner {
-  background-color: #f6f8fc;
+  background-color: #ffffff;
 }


@@ -0,0 +1,329 @@
+<template>
+  <el-dialog
+    :visible.sync="dialogVisible"
+    width="900px"
+    :title="$t('contextProviderDialog.title')"
+    :close-on-click-modal="false"
+    custom-class="context-provider-dialog"
+    append-to-body
+  >
+    <div class="dialog-content">
+      <el-empty v-if="localProviders.length === 0" :description="$t('contextProviderDialog.noContextApi')">
+        <el-button type="primary" icon="el-icon-plus" @click="addProvider(0)">{{ $t('contextProviderDialog.add') }}</el-button>
+      </el-empty>
+
+      <div
+        v-for="(provider, pIndex) in localProviders"
+        :key="pIndex"
+        class="provider-item"
+      >
+        <el-card class="provider-card" shadow="hover" :body-style="{ padding: '15px 20px' }">
+          <!-- URL Row -->
+          <div class="input-row">
+            <span class="label-text">{{ $t('contextProviderDialog.apiUrl') }}</span>
+            <el-input
+              v-model="provider.url"
+              :placeholder="$t('contextProviderDialog.apiUrlPlaceholder')"
+              size="small"
+              class="flex-1"
+            ></el-input>
+          </div>
+
+          <!-- Headers Section -->
+          <div class="headers-section">
+            <div class="label-text" style="margin-top: 6px;">{{ $t('contextProviderDialog.requestHeaders') }}</div>
+            <div class="headers-list">
+              <div
+                v-for="(header, hIndex) in provider.headers"
+                :key="hIndex"
+                class="header-row"
+              >
+                <el-input
+                  v-model="header.key"
+                  :placeholder="$t('contextProviderDialog.headerKeyPlaceholder')"
+                  size="small"
+                  style="width: 180px;"
+                ></el-input>
+                <span class="separator">:</span>
+                <el-input
+                  v-model="header.value"
+                  :placeholder="$t('contextProviderDialog.headerValuePlaceholder')"
+                  size="small"
+                  class="flex-1"
+                ></el-input>
+                
+                <div class="row-controls">
+                  <el-button
+                    type="primary"
+                    icon="el-icon-plus"
+                    circle
+                    size="mini"
+                    plain
+                    @click="addHeader(pIndex, hIndex + 1)"
+                  ></el-button>
+                  <el-button
+                    type="danger"
+                    icon="el-icon-minus"
+                    circle
+                    size="mini"
+                    plain
+                    @click="removeHeader(pIndex, hIndex)"
+                  ></el-button>
+                </div>
+              </div>
+              <!-- Empty Headers State -->
+              <div v-if="provider.headers.length === 0" class="header-row empty-header">
+                 <span class="no-header-text">{{ $t('contextProviderDialog.noHeaders') }}</span>
+                 <el-button
+                    type="text"
+                    icon="el-icon-plus"
+                    size="mini"
+                    @click="addHeader(pIndex, 0)"
+                  >{{ $t('contextProviderDialog.addHeader') }}</el-button>
+              </div>
+            </div>
+          </div>
+        </el-card>
+
+        <!-- Provider Block Controls (Right Side) -->
+        <div class="block-controls">
+          <el-button
+            type="primary"
+            icon="el-icon-plus"
+            circle
+            size="medium"
+            @click="addProvider(pIndex + 1)"
+          ></el-button>
+          <el-button
+            type="danger"
+            icon="el-icon-minus"
+            circle
+            size="medium"
+            @click="removeProvider(pIndex)"
+          ></el-button>
+        </div>
+      </div>
+    </div>
+
+    <span slot="footer" class="dialog-footer">
+      <el-button @click="dialogVisible = false">{{ $t('contextProviderDialog.cancel') }}</el-button>
+      <el-button type="primary" @click="handleConfirm">{{ $t('contextProviderDialog.confirm') }}</el-button>
+    </span>
+  </el-dialog>
+</template>
+
+<script>
+export default {
+  name: 'ContextProviderDialog',
+  props: {
+    visible: {
+      type: Boolean,
+      default: false
+    },
+    providers: {
+      type: Array,
+      default: () => []
+    }
+  },
+  data() {
+    return {
+      localProviders: []
+    };
+  },
+  computed: {
+    dialogVisible: {
+      get() {
+        return this.visible;
+      },
+      set(val) {
+        this.$emit('update:visible', val);
+      }
+    }
+  },
+  watch: {
+    visible(val) {
+      if (val) {
+        this.initLocalData();
+      }
+    }
+  },
+  methods: {
+    initLocalData() {
+      // 深拷贝并将 headers 对象转换为数组
+      this.localProviders = this.providers.map(p => {
+        const headers = p.headers || {};
+        return {
+          url: p.url || '',
+          headers: Object.entries(headers).map(([key, value]) => ({ key, value }))
+        };
+      });
+      
+      // 如果为空，添加一个默认块
+      if (this.localProviders.length === 0) {
+         this.localProviders.push({ url: '', headers: [{ key: '', value: '' }] });
+      }
+    },
+    addProvider(index) {
+      this.localProviders.splice(index, 0, {
+        url: '',
+        headers: [{ key: '', value: '' }]
+      });
+    },
+    removeProvider(index) {
+      this.localProviders.splice(index, 1);
+    },
+    addHeader(pIndex, hIndex) {
+      this.localProviders[pIndex].headers.splice(hIndex, 0, { key: '', value: '' });
+    },
+    removeHeader(pIndex, hIndex) {
+      this.localProviders[pIndex].headers.splice(hIndex, 1);
+    },
+    handleConfirm() {
+      const result = this.localProviders
+        .filter(p => p.url.trim() !== '')
+        .map(p => {
+          const headersObj = {};
+          p.headers.forEach(h => {
+            if (h.key.trim()) {
+              headersObj[h.key.trim()] = h.value;
+            }
+          });
+          return {
+            url: p.url.trim(),
+            headers: headersObj
+          };
+        });
+      
+      this.$emit('confirm', result);
+      this.dialogVisible = false;
+    }
+  }
+};
+</script>
+
+<style scoped>
+.dialog-content {
+  max-height: 60vh;
+  overflow-y: auto;
+  padding: 20px 25px;
+}
+
+.dialog-content::-webkit-scrollbar {
+  width: 6px;
+}
+.dialog-content::-webkit-scrollbar-thumb {
+  background: #dcdfe6;
+  border-radius: 3px;
+}
+.dialog-content::-webkit-scrollbar-track {
+  background: #f5f7fa;
+}
+
+.provider-item {
+  display: flex;
+  gap: 15px;
+  margin-bottom: 20px;
+  align-items: center;
+}
+
+.provider-card {
+  flex: 1;
+  border-radius: 12px;
+  border: 1px solid #e4e7ed;
+  border-left: 4px solid #409EFF; /* 左侧强调色 */
+  background-color: #fff;
+  transition: all 0.3s ease;
+  box-shadow: 0 2px 12px 0 rgba(0, 0, 0, 0.05);
+}
+
+.provider-card:hover {
+  box-shadow: 0 8px 20px rgba(0, 0, 0, 0.1);
+  transform: translateY(-2px);
+}
+
+.block-controls {
+  display: flex;
+  flex-direction: row;
+  gap: 8px;
+}
+
+.input-row {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  margin-bottom: 18px;
+}
+
+.label-text {
+  width: 60px;
+  font-weight: 600;
+  color: #606266;
+  text-align: right;
+  font-size: 13px;
+  white-space: nowrap;
+  line-height: 32px; /* 垂直居中对齐 */
+}
+
+.flex-1 {
+  flex: 1;
+}
+
+.headers-section {
+  display: flex;
+  gap: 12px;
+  align-items: flex-start;
+}
+
+.headers-list {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  background: #fcfcfc;
+  padding: 15px;
+  border-radius: 8px;
+  border: 1px dashed #dcdfe6;
+  transition: all 0.3s;
+}
+
+.headers-list:hover {
+  border-color: #c0c4cc;
+  background: #fff;
+}
+
+.header-row {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+}
+
+.separator {
+  color: #909399;
+  font-weight: bold;
+  margin: 0 2px;
+}
+
+.row-controls {
+  display: flex;
+  gap: 6px;
+  margin-left: 8px;
+  flex-shrink: 0;
+  opacity: 0.6;
+  transition: opacity 0.2s;
+}
+
+.header-row:hover .row-controls {
+  opacity: 1;
+}
+
+.empty-header {
+  justify-content: center;
+  padding: 10px;
+  color: #909399;
+  font-size: 13px;
+}
+
+.no-header-text {
+  margin-right: 8px;
+}
+</style>
@@ -23,7 +23,7 @@
      <div class="settings-btn" @click="handleConfigure">
        {{ $t('home.configureRole') }}
      </div>
-      <div class="settings-btn" @click="handleVoicePrint">
+      <div v-if="featureStatus.voiceprintRecognition" class="settings-btn" @click="handleVoicePrint">
        {{ $t('home.voiceprintRecognition') }}
      </div>
      <div class="settings-btn" @click="handleDeviceManage">
@@ -49,7 +49,15 @@ import i18n from '@/i18n';
 export default {
  name: 'DeviceItem',
  props: {
-    device: { type: Object, required: true }
+    device: { type: Object, required: true },
+    featureStatus: { 
+      type: Object, 
+      default: () => ({
+        voiceprintRecognition: false,
+        voiceClone: false,
+        knowledgeBase: false
+      })
+    }
  },
  data() {
    return { switchValue: false }
@@ -106,7 +106,7 @@
    </div>

    <!-- MCP区域 -->
-    <div class="mcp-access-point">
+    <div class="mcp-access-point" v-if="featureStatus.mcpAccessPoint">
      <div class="mcp-container">
        <!-- 左侧区域 -->
        <div class="mcp-left">
@@ -171,6 +171,7 @@
 <script>
 import Api from '@/apis/api';
 import i18n from '@/i18n';
+import featureManager from '@/utils/featureManager';

 export default {
  i18n,
@@ -205,6 +206,11 @@ export default {
      mcpUrl: "",
      mcpStatus: "disconnected",
      mcpTools: [],
+      
+      // 功能状态
+      featureStatus: {
+        mcpAccessPoint: false
+      }
    }
  },
  computed: {
@@ -249,6 +255,9 @@ export default {
        // 右侧默认指向第一个
        this.currentFunction = this.selectedList[0] || null;

+        // 加载功能状态
+        this.loadFeatureStatus();
+        
        // 加载MCP数据
        this.loadMcpAddress();
        this.loadMcpTools();
@@ -259,6 +268,19 @@ export default {
    }
  },
  methods: {
+    /**
+     * 加载功能状态
+     */
+    async loadFeatureStatus() {
+      // 确保featureManager已初始化完成
+      await featureManager.waitForInitialization();
+      
+      const config = featureManager.getConfig();
+      this.featureStatus = {
+        mcpAccessPoint: config.mcpAccessPoint || false
+      };
+    },
+    
    copyUrl() {
      const textarea = document.createElement('textarea');
      textarea.value = this.mcpUrl;
@@ -456,6 +478,7 @@ export default {
 .function-column {
  position: relative;
  width: auto;
+  height:700px; 
  padding: 10px;
  overflow-y: auto;
  border-right: 1px solid #EBEEF5;
@@ -463,6 +486,12 @@ export default {
  overflow-x: hidden;
 }

+.mcp-access-point {
+  position: relative;
+  z-index: 1;
+  background: white;
+}
+
 .function-column::-webkit-scrollbar {
  display: none;
 }
@@ -4,7 +4,7 @@
      <!-- 左侧元素 -->
      <div class="header-left" @click="goHome">
        <img loading="lazy" alt="" src="@/assets/xiaozhi-logo.png" class="logo-img" />
-        <img loading="lazy" alt="" src="@/assets/xiaozhi-ai.png" class="brand-img" />
+        <img loading="lazy" alt="" :src="xiaozhiAiIcon" class="brand-img" />
      </div>

      <!-- 中间导航菜单 -->
@@ -26,7 +26,7 @@
          <span class="nav-text">{{ $t("header.smartManagement") }}</span>
        </div>
        <!-- 普通用户显示音色克隆 -->
-        <div v-if="!isSuperAdmin" class="equipment-management"
+        <div v-if="!isSuperAdmin && featureStatus.voiceClone" class="equipment-management"
          :class="{ 'active-tab': $route.path === '/voice-clone-management' }" @click="goVoiceCloneManagement">
          <img loading="lazy" alt="" src="@/assets/header/voice.png" :style="{
            filter:
@@ -38,7 +38,7 @@
        </div>

        <!-- 超级管理员显示音色克隆下拉菜单 -->
-        <el-dropdown v-if="isSuperAdmin" trigger="click" class="equipment-management more-dropdown" :class="{
+        <el-dropdown v-if="isSuperAdmin && featureStatus.voiceClone" trigger="click" class="equipment-management more-dropdown" :class="{
          'active-tab':
            $route.path === '/voice-clone-management' ||
            $route.path === '/voice-resource-management',
@@ -72,7 +72,7 @@
          }" />
          <span class="nav-text">{{ $t("header.modelConfig") }}</span>
        </div>
-        <div class="equipment-management"
+        <div v-if="featureStatus.knowledgeBase" class="equipment-management"
          :class="{ 'active-tab': $route.path === '/knowledge-base-management' || $route.path === '/knowledge-file-upload' }"
          @click="goKnowledgeBaseManagement">
          <img loading="lazy" alt="" src="@/assets/header/knowledge_base.png" :style="{
@@ -89,7 +89,8 @@
            $route.path === '/server-side-management' ||
            $route.path === '/agent-template-management' ||
            $route.path === '/ota-management' ||
-            $route.path === '/user-management',
+            $route.path === '/user-management' ||
+            $route.path === '/feature-management',
        }" @visible-change="handleParamDropdownVisibleChange">
          <span class="el-dropdown-link">
            <img loading="lazy" alt="" src="@/assets/header/param_management.png" :style="{
@@ -100,7 +101,8 @@
                  $route.path === '/server-side-management' ||
                  $route.path === '/agent-template-management' ||
                  $route.path === '/ota-management' ||
-                  $route.path === '/user-management'
+                  $route.path === '/user-management' ||
+                  $route.path === '/feature-management'
                  ? 'brightness(0) invert(1)'
                  : 'None',
            }" />
@@ -129,6 +131,9 @@
            <el-dropdown-item @click.native="goServerSideManagement">
              {{ $t("header.serverSideManagement") }}
            </el-dropdown-item>
+            <el-dropdown-item @click.native="goFeatureManagement">
+                {{ $t("header.featureManagement") }}
+              </el-dropdown-item>
          </el-dropdown-menu>
        </el-dropdown>
      </div>
@@ -186,6 +191,7 @@ import userApi from "@/apis/module/user";
 import i18n, { changeLanguage } from "@/i18n";
 import { mapActions, mapGetters } from "vuex";
 import ChangePasswordDialog from "./ChangePasswordDialog.vue"; // 引入修改密码弹窗组件
+import featureManager from "@/utils/featureManager"; // 引入功能管理工具类

 export default {
  name: "HeaderBar",
@@ -217,6 +223,11 @@ export default {
        label: "label",
        children: "children",
      },
+      // 功能状态
+      featureStatus: {
+        voiceClone: false, // 音色克隆功能状态
+        knowledgeBase: false, // 知识库功能状态
+      },
    };
  },
  computed: {
@@ -246,6 +257,24 @@ export default {
          return this.$t("language.zhCN");
      }
    },
+    // 根据当前语言获取对应的xiaozhi-ai图标
+    xiaozhiAiIcon() {
+      const currentLang = this.currentLanguage;
+      switch (currentLang) {
+        case "zh_CN":
+          return require("@/assets/xiaozhi-ai.png");
+        case "zh_TW":
+          return require("@/assets/xiaozhi-ai_zh_TW.png");
+        case "en":
+          return require("@/assets/xiaozhi-ai_en.png");
+        case "de":
+          return require("@/assets/xiaozhi-ai_de.png");
+        case "vi":
+          return require("@/assets/xiaozhi-ai_vi.png");
+        default:
+          return require("@/assets/xiaozhi-ai.png");
+      }
+    },
    // 用户菜单选项
    userMenuOptions() {
      return [
@@ -286,12 +315,14 @@ export default {
      ];
    },
  },
-  mounted() {
+  async mounted() {
    this.fetchUserInfo();
    this.checkScreenSize();
    window.addEventListener("resize", this.checkScreenSize);
    // 从localStorage加载搜索历史
    this.loadSearchHistory();
+    // 等待featureManager初始化完成后再加载功能状态
+    await this.loadFeatureStatus();
  },
  //移除事件监听器
  beforeDestroy() {
@@ -338,6 +369,20 @@ export default {
    goAgentTemplateManagement() {
      this.$router.push("/agent-template-management");
    },
+    // 跳转到功能管理
+    goFeatureManagement() {
+      this.$router.push("/feature-management");
+    },
+    // 加载功能状态
+    async loadFeatureStatus() {
+      // 等待featureManager初始化完成
+      await featureManager.waitForInitialization();
+      
+      const config = featureManager.getConfig();
+      
+      this.featureStatus.voiceClone = config.voiceClone;
+      this.featureStatus.knowledgeBase = config.knowledgeBase;
+    },
    // 获取用户信息
    fetchUserInfo() {
      userApi.getUserInfo(({ data }) => {
@@ -22,6 +22,7 @@ export default {
  'header.clearHistory': 'Clear History',
  'header.providerManagement': 'Provider Management',
  'header.serverSideManagement': 'Server Management',
+  'header.featureManagement': 'System Feature Management',
  'header.changePassword': 'Change Password',
  'header.logout': 'Logout',
  'header.searchPlaceholder': 'Search by name..',
@@ -229,6 +230,26 @@ export default {
  'voicePrintDialog.requiredName': 'Please enter name',
  'voicePrintDialog.requiredAudioVector': 'Please select audio vector',

+  // Context provider dialog related
+  'contextProviderDialog.title': 'Edit Source',
+  'contextProviderDialog.noContextApi': 'No Context API',
+  'contextProviderDialog.add': 'Add',
+  'contextProviderDialog.apiUrl': 'API URL',
+  'contextProviderDialog.apiUrlPlaceholder': 'http://api.example.com/data',
+  'contextProviderDialog.requestHeaders': 'Request Headers',
+  'contextProviderDialog.headerKeyPlaceholder': 'Key',
+  'contextProviderDialog.headerValuePlaceholder': 'Value',
+  'contextProviderDialog.noHeaders': 'No Headers',
+  'contextProviderDialog.addHeader': 'Add Header',
+  'contextProviderDialog.cancel': 'Cancel',
+  'contextProviderDialog.confirm': 'Confirm',
+
+  // Role config page - context provider related
+  'roleConfig.contextProvider': 'Context',
+  'roleConfig.contextProviderSuccess': 'Successfully added {count} sources.',
+  'roleConfig.contextProviderDocLink': 'How to deploy context provider',
+  'roleConfig.editContextProvider': 'Edit Source',
+
  // Voice print page related
  'voicePrint.pageTitle': 'Voice Print Recognition',
  'voicePrint.name': 'Name',
@@ -692,7 +713,7 @@ export default {
  'paramManagement.deleteFailed': 'Deletion failed, please try again',
  'paramManagement.operationCancelled': 'Deletion cancelled',
  'paramManagement.operationClosed': 'Operation closed',
-  'paramManagement.updateSuccess': 'Update successful',
+  'paramManagement.updateSuccess': 'Update successful. Some configurations will take effect only after restarting the xiaozhi-server module.',
  'paramManagement.addSuccess': 'Add successful',
  'paramManagement.updateFailed': 'Update failed',
  'paramManagement.addFailed': 'Add failed',
@@ -800,7 +821,7 @@ export default {
  'modelConfig.rag': 'RAG',
  'modelConfig.modelId': 'Model ID',
  'modelConfig.modelName': 'Model Name',
-  'modelConfig.provider': 'Provider',
+  'modelConfig.provider': 'Interface Type',
  'modelConfig.unknown': 'Unknown',
  'modelConfig.isEnabled': 'Enabled',
  'modelConfig.isDefault': 'Default',
@@ -831,7 +852,7 @@ export default {
  'modelConfig.enableSuccess': 'Enable successful',
  'modelConfig.disableSuccess': 'Disable successful',
  'modelConfig.operationFailed': 'Operation failed',
-  'modelConfig.setDefaultSuccess': 'Set default model successful',
+  'modelConfig.setDefaultSuccess': 'Set default model successful, please restart the xiaozhi-server module manually in time',
  'modelConfig.itemsPerPage': '{items} items/page',
  'modelConfig.firstPage': 'First Page',
  'modelConfig.prevPage': 'Previous Page',
@@ -849,6 +870,7 @@ export default {
  'modelConfigDialog.setDefault': 'Set as Default',
  'modelConfigDialog.modelId': 'Model ID',
  'modelConfigDialog.enterModelId': 'If not filled in, it will be generated automatically',
+  'modelConfigDialog.invalidModelId': 'Model ID cannot be pure text or spaces, please use letters, numbers, underscores, or hyphens',
  'modelConfigDialog.modelName': 'Model Name',
  'modelConfigDialog.enterModelName': 'Please enter model name',
  'modelConfigDialog.modelCode': 'Model Code',
@@ -1261,4 +1283,35 @@ export default {
  'knowledgeFileUpload.content': 'Content:',
  'knowledgeFileUpload.testQuestionRequired': 'Please enter test question',
  'knowledgeBaseDialog.descriptionRequired': 'Please enter knowledge base description',
+
+  // Feature Management page text
+  'featureManagement.selectAll': 'Select All',
+  'featureManagement.deselectAll': 'Deselect All',
+  'featureManagement.save': 'Save Configuration',
+  'featureManagement.reset': 'Reset',
+  'featureManagement.group.featureManagement': 'Enable/Disable the feature/section',
+  'featureManagement.group.voiceManagement': 'Visible to users during agent configuration',
+  'featureManagement.noFeatures': 'No features available',
+  'featureManagement.contactAdmin': 'Please contact administrator to configure features',
+  'featureManagement.saveSuccess': 'Feature configuration saved successfully',
+  'featureManagement.resetConfirm': 'Are you sure you want to reset all feature configurations?',
+  'featureManagement.confirm': 'Confirm',
+  'featureManagement.cancel': 'Cancel',
+  'featureManagement.resetSuccess': 'Feature configuration reset successfully',
+  'featureManagement.noChanges': 'No changes to save',
+
+  // Feature names and descriptions
+  'feature.voiceprintRecognition.name': 'Voiceprint Recognition',
+  'feature.voiceprintRecognition.description': 'Verify user identity through voiceprint recognition technology, providing secure voice interaction experience',
+  'feature.voiceClone.name': 'Voice Clone',
+  'feature.voiceClone.description': 'Clone specific voice timbre using AI technology to achieve personalized voice synthesis',
+  'feature.knowledgeBase.name': 'Knowledge Base',
+  'feature.knowledgeBase.description': 'Build and manage knowledge base system to provide professional knowledge support for AI assistants',
+  'feature.mcpAccessPoint.name': 'MCP Access Point',
+  'feature.mcpAccessPoint.description': 'Provide MCP protocol access points to support integration of external tools and services',
+  'feature.vad.name': 'Voice Activity Detection',
+  'feature.vad.description': 'Automatically detect voice activity to optimize voice interaction response efficiency',
+  'feature.asr.name': 'Speech Recognition',
+  'feature.asr.description': 'Convert speech to text to enable natural language interaction functionality',
+
 }
@@ -22,6 +22,7 @@ export default {
  'header.clearHistory': '清空历史',
  'header.providerManagement': '字段管理',
  'header.serverSideManagement': '服务端管理',
+  'header.featureManagement': '系统功能配置',
  'header.changePassword': '修改密码',
  'header.logout': '退出登录',
  'header.searchPlaceholder': '输入名称搜索..',
@@ -229,6 +230,26 @@ export default {
  'voicePrintDialog.requiredName': '请输入姓名',
  'voicePrintDialog.requiredAudioVector': '请选择音频向量',

+  // 上下文源对话框相关
+  'contextProviderDialog.title': '编辑源',
+  'contextProviderDialog.noContextApi': '暂无上下文API',
+  'contextProviderDialog.add': '添加',
+  'contextProviderDialog.apiUrl': '接口地址',
+  'contextProviderDialog.apiUrlPlaceholder': 'http://api.example.com/data',
+  'contextProviderDialog.requestHeaders': '请求头',
+  'contextProviderDialog.headerKeyPlaceholder': 'Key',
+  'contextProviderDialog.headerValuePlaceholder': 'Value',
+  'contextProviderDialog.noHeaders': '暂无 Headers',
+  'contextProviderDialog.addHeader': '添加 Header',
+  'contextProviderDialog.cancel': '取消',
+  'contextProviderDialog.confirm': '确定',
+
+  // 角色配置页面-上下文源相关
+  'roleConfig.contextProvider': '上下文源',
+  'roleConfig.contextProviderSuccess': '已成功添加 {count} 个源。',
+  'roleConfig.contextProviderDocLink': '如何部署上下文源',
+  'roleConfig.editContextProvider': '编辑源',
+
  // 声纹页面相关
  'voicePrint.pageTitle': '声纹识别',
  'voicePrint.name': '姓名',
@@ -692,7 +713,7 @@ export default {
  'paramManagement.deleteFailed': '删除失败，请重试',
  'paramManagement.operationCancelled': '已取消删除操作',
  'paramManagement.operationClosed': '操作已关闭',
-  'paramManagement.updateSuccess': '修改成功',
+  'paramManagement.updateSuccess': '修改成功，部分配置需重启xiaozhi-server模块才生效',
  'paramManagement.addSuccess': '新增成功',
  'paramManagement.updateFailed': '更新失败',
  'paramManagement.addFailed': '新增失败',
@@ -800,7 +821,7 @@ export default {
  'modelConfig.rag': '知识库',
  'modelConfig.modelId': '模型ID',
  'modelConfig.modelName': '模型名称',
-  'modelConfig.provider': '提供商',
+  'modelConfig.provider': '接口类型',
  'modelConfig.unknown': '未知',
  'modelConfig.isEnabled': '是否启用',
  'modelConfig.isDefault': '是否默认',
@@ -831,7 +852,7 @@ export default {
  'modelConfig.enableSuccess': '启用成功',
  'modelConfig.disableSuccess': '禁用成功',
  'modelConfig.operationFailed': '操作失败',
-  'modelConfig.setDefaultSuccess': '设置默认模型成功',
+  'modelConfig.setDefaultSuccess': '设置默认模型成功，请及时手动重启xiaozhi-server模块',
  'modelConfig.itemsPerPage': '{items}条/页',
  'modelConfig.firstPage': '首页',
  'modelConfig.prevPage': '上一页',
@@ -849,6 +870,7 @@ export default {
  'modelConfigDialog.setDefault': '设为默认',
  'modelConfigDialog.modelId': '模型ID',
  'modelConfigDialog.enterModelId': '未填写将自动生成模型ID',
+  'modelConfigDialog.invalidModelId': '模型ID不能为纯文字或空格，请使用字母、数字、下划线或连字符组合',
  'modelConfigDialog.modelName': '模型名称',
  'modelConfigDialog.enterModelName': '请输入模型名称',
  'modelConfigDialog.modelCode': '模型编码',
@@ -1261,4 +1283,35 @@ export default {
  'knowledgeFileUpload.content': '内容:',
  'knowledgeFileUpload.testQuestionRequired': '请输入测试问题',
  'knowledgeBaseDialog.descriptionRequired': '请输入知识库描述',
+
+  // 系统功能配置页面文本
+  'featureManagement.selectAll': '全选',
+  'featureManagement.deselectAll': '取消全选',
+  'featureManagement.save': '保存配置',
+  'featureManagement.reset': '重置',
+  'featureManagement.group.featureManagement': '是否开启功能/板块',
+  'featureManagement.group.voiceManagement': '配置智能体时是否对用户可见',
+  'featureManagement.noFeatures': '暂无功能',
+  'featureManagement.contactAdmin': '请联系管理员配置功能',
+  'featureManagement.saveSuccess': '功能配置保存成功',
+  'featureManagement.resetConfirm': '确定要重置所有功能配置吗？',
+  'featureManagement.confirm': '确定',
+  'featureManagement.cancel': '取消',
+  'featureManagement.resetSuccess': '功能配置重置成功',
+  'featureManagement.noChanges': '没有需要保存的更改',
+
+  // 功能名称和描述
+  'feature.voiceprintRecognition.name': '声纹识别',
+  'feature.voiceprintRecognition.description': '通过声纹识别技术验证用户身份，提供安全的语音交互体验',
+  'feature.voiceClone.name': '音色克隆',
+  'feature.voiceClone.description': '使用AI技术克隆特定音色，实现个性化语音合成',
+  'feature.knowledgeBase.name': '知识库',
+  'feature.knowledgeBase.description': '构建和管理知识库系统，为AI助手提供专业知识支持',
+  'feature.mcpAccessPoint.name': 'MCP接入点',
+  'feature.mcpAccessPoint.description': '提供MCP协议接入点，支持外部工具和服务的集成',
+  'feature.vad.name': '语音活动检测',
+  'feature.vad.description': '自动检测语音活动，优化语音交互的响应效率',
+  'feature.asr.name': '语音识别',
+  'feature.asr.description': '将语音转换为文本，实现自然语言交互功能',
+
 }
@@ -22,6 +22,7 @@ export default {
  'header.clearHistory': '清空歷史',
  'header.providerManagement': '字段管理',
  'header.serverSideManagement': '服務端管理',
+  'header.featureManagement': '系統功能配置',
  'header.changePassword': '修改密碼',
  'header.logout': '退出登錄',
  'header.searchPlaceholder': '輸入名稱搜索..',
@@ -229,6 +230,26 @@ export default {
  'voicePrintDialog.requiredName': '請輸入姓名',
  'voicePrintDialog.requiredAudioVector': '請選擇音頻向量',

+  // 上下文源對話框相關
+  'contextProviderDialog.title': '編輯源',
+  'contextProviderDialog.noContextApi': '暫無上下文API',
+  'contextProviderDialog.add': '添加',
+  'contextProviderDialog.apiUrl': '接口地址',
+  'contextProviderDialog.apiUrlPlaceholder': 'http://api.example.com/data',
+  'contextProviderDialog.requestHeaders': '請求頭',
+  'contextProviderDialog.headerKeyPlaceholder': 'Key',
+  'contextProviderDialog.headerValuePlaceholder': 'Value',
+  'contextProviderDialog.noHeaders': '暫無 Headers',
+  'contextProviderDialog.addHeader': '添加 Header',
+  'contextProviderDialog.cancel': '取消',
+  'contextProviderDialog.confirm': '確定',
+
+  // 角色配置頁面-上下文源相關
+  'roleConfig.contextProvider': '上下文源',
+  'roleConfig.contextProviderSuccess': '已成功添加 {count} 個源。',
+  'roleConfig.contextProviderDocLink': '如何部署上下文源',
+  'roleConfig.editContextProvider': '編輯源',
+
  // 聲紋頁面相關
  'voicePrint.pageTitle': '聲紋識別',
  'voicePrint.name': '姓名',
@@ -692,7 +713,7 @@ export default {
  'paramManagement.deleteFailed': '刪除失敗，請重試',
  'paramManagement.operationCancelled': '已取消刪除操作',
  'paramManagement.operationClosed': '操作已關閉',
-  'paramManagement.updateSuccess': '修改成功',
+  'paramManagement.updateSuccess': '修改成功，部分配置需重啟xiaozhi-server模組才生效',
  'paramManagement.addSuccess': '新增成功',
  'paramManagement.updateFailed': '更新失敗',
  'paramManagement.addFailed': '新增失敗',
@@ -800,7 +821,7 @@ export default {
  'modelConfig.rag': '知識庫',
  'modelConfig.modelId': '模型ID',
  'modelConfig.modelName': '模型名稱',
-  'modelConfig.provider': '提供商',
+  'modelConfig.provider': '接口類型',
  'modelConfig.unknown': '未知',
  'modelConfig.isEnabled': '是否啟用',
  'modelConfig.isDefault': '是否默認',
@@ -831,7 +852,7 @@ export default {
  'modelConfig.enableSuccess': '啟用成功',
  'modelConfig.disableSuccess': '禁用成功',
  'modelConfig.operationFailed': '操作失敗',
-  'modelConfig.setDefaultSuccess': '設置默認模型成功',
+  'modelConfig.setDefaultSuccess': '設置默認模型成功，請及時手動重啟xiaozhi-server模組',
  'modelConfig.itemsPerPage': '{items}條/頁',
  'modelConfig.firstPage': '首頁',
  'modelConfig.prevPage': '上一頁',
@@ -849,6 +870,7 @@ export default {
  'modelConfigDialog.setDefault': '設為默認',
  'modelConfigDialog.modelId': '模型ID',
  'modelConfigDialog.enterModelId': '未填冩將自動生成模型ID',
+  'modelConfigDialog.invalidModelId': '模型ID不能為純文字或空格，請使用字母、數字、底線或連字符組合',
  'modelConfigDialog.modelName': '模型名稱',
  'modelConfigDialog.enterModelName': '請輸入模型名稱',
  'modelConfigDialog.modelCode': '模型編碼',
@@ -1261,4 +1283,35 @@ export default {
  'knowledgeFileUpload.content': '內容:',
  'knowledgeFileUpload.testQuestionRequired': '請輸入測試問題',
  'knowledgeBaseDialog.descriptionRequired': '請輸入知识库描述',
+
+  // 功能管理頁面文本
+  'featureManagement.selectAll': '全選',
+  'featureManagement.deselectAll': '取消全選',
+  'featureManagement.save': '儲存配置',
+  'featureManagement.reset': '重置',
+  'featureManagement.group.featureManagement': '是否開啟功能/板块',
+  'featureManagement.group.voiceManagement': '配置智能体時是否對用戶可見',
+  'featureManagement.noFeatures': '暫無功能',
+  'featureManagement.contactAdmin': '請聯繫管理員配置功能',
+  'featureManagement.saveSuccess': '功能配置儲存成功',
+  'featureManagement.resetConfirm': '確定要重置所有功能配置嗎？',
+  'featureManagement.confirm': '確定',
+  'featureManagement.cancel': '取消',
+  'featureManagement.resetSuccess': '功能配置重置成功',
+  'featureManagement.noChanges': '沒有需要儲存的更改',
+
+  // 功能名稱和描述
+  'feature.voiceprintRecognition.name': '聲紋識別',
+  'feature.voiceprintRecognition.description': '通過聲紋識別技術驗證用戶身份，提供安全的語音交互體驗',
+  'feature.voiceClone.name': '音色複刻',
+  'feature.voiceClone.description': '使用AI技術複刻特定音色，實現個性化語音合成',
+  'feature.knowledgeBase.name': '知識庫',
+  'feature.knowledgeBase.description': '構建和管理知識庫系統，為AI助手提供專業知識支持',
+  'feature.mcpAccessPoint.name': 'MCP接入點',
+  'feature.mcpAccessPoint.description': '提供MCP協議接入點，支持外部工具和服務的整合',
+  'feature.vad.name': '語音活動檢測',
+  'feature.vad.description': '自動檢測語音活動，優化語音交互的響應效率',
+  'feature.asr.name': '語音識別',
+  'feature.asr.description': '將語音轉換為文本，實現自然語言交互功能',
+
 }
@@ -8,6 +8,7 @@ import store from './store';
 import i18n from './i18n';
 import './styles/global.scss';
 import { register as registerServiceWorker } from './registerServiceWorker';
+import featureManager from './utils/featureManager';

 // 创建事件总线，用于组件间通信
 Vue.prototype.$eventBus = new Vue();
@@ -76,7 +76,8 @@ const routes = [
      return import('../views/ModelConfig.vue')
    }
  },
-  { path: '/params-management',
+  {
+    path: '/params-management',
    name: 'ParamsManagement',
    component: function () {
      return import('../views/ParamsManagement.vue')
@@ -86,7 +87,8 @@ const routes = [
      title: '参数管理'
    }
  },
-  { path: '/knowledge-base-management',
+  {
+    path: '/knowledge-base-management',
    name: 'KnowledgeBaseManagement',
    component: function () {
      return import('../views/KnowledgeBaseManagement.vue')
@@ -96,7 +98,8 @@ const routes = [
      title: '知识库管理'
    }
  },
-  { path: '/knowledge-file-upload',
+  {
+    path: '/knowledge-file-upload',
    name: 'KnowledgeFileUpload',
    component: function () {
      return import('../views/KnowledgeFileUpload.vue')
@@ -181,6 +184,18 @@ const routes = [
      return import('../views/TemplateQuickConfig.vue')
    }
  },
+  // 功能配置页面路由
+  {
+    path: '/feature-management',
+    name: 'FeatureManagement',
+    component: function () {
+      return import('../views/FeatureManagement.vue')
+    },
+    meta: {
+      requiresAuth: true,
+      title: '功能配置'
+    }
+  },
 ]
 const router = new VueRouter({
  base: process.env.VUE_APP_PUBLIC_PATH || '/',
@@ -0,0 +1,340 @@
+//功能配置工具
+import Api from "@/apis/api";
+
+class FeatureManager {
+    constructor() {
+        this.defaultFeatures = {
+            voiceprintRecognition: {
+                name: 'feature.voiceprintRecognition.name',
+                enabled: false,
+                description: 'feature.voiceprintRecognition.description'
+            },
+            voiceClone: {
+                name: 'feature.voiceClone.name',
+                enabled: false,
+                description: 'feature.voiceClone.description'
+            },
+            knowledgeBase: {
+                name: 'feature.knowledgeBase.name',
+                enabled: false,
+                description: 'feature.knowledgeBase.description'
+            },
+            mcpAccessPoint: {
+                name: 'feature.mcpAccessPoint.name',
+                enabled: false,
+                description: 'feature.mcpAccessPoint.description'
+            },
+            vad: {
+                name: 'feature.vad.name',
+                enabled: false,
+                description: 'feature.vad.description'
+            },
+            asr: {
+                name: 'feature.asr.name',
+                enabled: false,
+                description: 'feature.asr.description'
+            }
+        };
+        this.currentFeatures = { ...this.defaultFeatures }; // 当前内存中的配置
+        this.initialized = false;
+        this.initPromise = null;
+    }
+
+    /**
+     * 等待初始化完成
+     */
+    async waitForInitialization() {
+        if (!this.initPromise) {
+            this.initPromise = this.init();
+        }
+        await this.initPromise;
+        return this.initialized;
+    }
+
+    /**
+     * 初始化功能配置
+     */
+    async init() {
+        try {
+            // 从pub-config接口获取配置
+            const config = await this.getConfigFromPubConfig();
+            if (config) {
+                this.currentFeatures = { ...config }; // 保存到内存
+                this.initialized = true;
+                return;
+            }
+        } catch (error) {
+            console.warn('从pub-config接口获取配置失败:', error);
+        }
+
+        // pub-config接口失败，使用默认配置
+        this.currentFeatures = { ...this.defaultFeatures }; // 保存默认配置到内存
+        this.initialized = true;
+    }
+
+
+
+    /**
+     * 从pub-config接口获取配置
+     */
+    async getConfigFromPubConfig() {
+        return new Promise((resolve) => {
+            // 直接调用pub-config接口获取配置
+            Api.user.getPubConfig((result) => {
+                // 检查返回结果的结构
+                if (result && result.status === 200) {
+                    // 检查是否有data字段
+                    if (result.data) {
+                        // 检查是否有code字段，如果有则按照code判断
+                        if (result.data.code !== undefined) {
+                            if (result.data.code === 0 && result.data.data && result.data.data.systemWebMenu) {
+                                try {
+                                    let config;
+                                    if (typeof result.data.data.systemWebMenu === 'string') {
+                                        // 如果是字符串，需要解析JSON
+                                        config = JSON.parse(result.data.data.systemWebMenu);
+                                    } else {
+                                        // 如果已经是对象，直接使用
+                                        config = result.data.data.systemWebMenu;
+                                    }
+
+                                    // 检查配置中是否包含features对象
+                                    if (config && config.features) {
+                                        // 确保knowledgeBase功能存在且配置正确
+                                        if (!config.features.knowledgeBase) {
+                                            console.warn('配置中缺少knowledgeBase功能，合并默认配置');
+                                            config.features = { ...this.defaultFeatures, ...config.features };
+                                        }
+                                        resolve(config.features);
+                                    } else {
+                                        console.warn('配置中缺少features对象，使用默认配置');
+                                        resolve(this.defaultFeatures);
+                                    }
+                                } catch (error) {
+                                    console.warn('处理systemWebMenu配置失败:', error);
+                                    resolve(null);
+                                }
+                            } else {
+                                console.warn('接口返回code不为0或缺少必要数据，使用默认配置');
+                                resolve(null);
+                            }
+                        } else {
+                            // 如果没有code字段，直接检查systemWebMenu
+                            if (result.data && result.data.systemWebMenu) {
+                                try {
+                                    let config;
+                                    if (typeof result.data.systemWebMenu === 'string') {
+                                        // 如果是字符串，需要解析JSON
+                                        config = JSON.parse(result.data.systemWebMenu);
+                                    } else {
+                                        // 如果已经是对象，直接使用
+                                        config = result.data.systemWebMenu;
+                                    }
+
+                                    // 检查配置中是否包含features对象
+                                    if (config && config.features) {
+                                        // 确保knowledgeBase功能存在且配置正确
+                                        if (!config.features.knowledgeBase) {
+                                            console.warn('配置中缺少knowledgeBase功能，合并默认配置');
+                                            config.features = { ...this.defaultFeatures, ...config.features };
+                                        }
+                                        resolve(config.features);
+                                    } else {
+                                        console.warn('配置中缺少features对象，使用默认配置');
+                                        resolve(this.defaultFeatures);
+                                    }
+                                } catch (error) {
+                                    console.warn('处理systemWebMenu配置失败:', error);
+                                    resolve(null);
+                                }
+                            } else {
+                                console.warn('接口返回缺少systemWebMenu数据，使用默认配置');
+                                resolve(null);
+                            }
+                        }
+                    } else {
+                        console.warn('接口返回数据中缺少data字段，使用默认配置');
+                        resolve(null);
+                    }
+                } else {
+                    console.warn('pub-config接口调用失败，使用默认配置');
+                    resolve(null);
+                }
+            });
+        });
+    }
+
+    /**
+     * 获取当前配置
+     */
+    getCurrentConfig() {
+        // 返回内存中的当前配置
+        return this.currentFeatures;
+    }
+
+    /**
+     * 保存配置到后端API
+     */
+    async saveConfig(config) {
+        try {
+            // 更新内存中的配置
+            this.currentFeatures = { ...config };
+
+            // 异步保存到后端API
+            this.saveConfigToAPI(config).catch(error => {
+                console.warn('保存配置到API失败:', error);
+            });
+
+            // 触发配置变更事件
+            window.dispatchEvent(new CustomEvent('featureConfigChanged', {
+                detail: config
+            }));
+        } catch (error) {
+            console.error('保存功能配置失败:', error);
+        }
+    }
+
+    /**
+     * 保存配置到后端API
+     */
+    async saveConfigToAPI(config) {
+        return new Promise((resolve) => {
+            // 直接使用已知的ID（600）更新参数
+            Api.admin.updateParam(
+                {
+                    id: 600,
+                    paramCode: 'system-web.menu',
+                    paramValue: JSON.stringify({
+                        features: config,
+                        groups: {
+                            featureManagement: ["voiceprintRecognition", "voiceClone", "knowledgeBase", "mcpAccessPoint"],
+                            voiceManagement: ["vad", "asr"]
+                        }
+                    }),
+                    valueType: 'json',
+                    remark: '系统功能菜单配置'
+                },
+                (updateResult) => {
+                    if (updateResult.code === 0) {
+                        resolve();
+                    } else {
+                        // 如果更新失败，可能是参数不存在或其他错误，记录但不阻止保存到localStorage
+                        console.warn('更新参数失败:', updateResult.msg);
+                        resolve(); // 不阻止保存到localStorage
+                    }
+                },
+                (error) => {
+                    console.warn('更新参数失败:', error);
+                    resolve(); // 不阻止保存到localStorage
+                }
+            );
+        });
+    }
+
+
+
+    /**
+     * 获取所有功能配置
+     */
+    getAllFeatures() {
+        return this.getCurrentConfig();
+    }
+
+    /**
+     * 获取简化的配置对象（用于首页组件）
+     */
+    getConfig() {
+        const features = this.getAllFeatures();
+        return {
+            voiceprintRecognition: features.voiceprintRecognition?.enabled || false,
+            voiceClone: features.voiceClone?.enabled || false,
+            knowledgeBase: features.knowledgeBase?.enabled || false,
+            mcpAccessPoint: features.mcpAccessPoint?.enabled || false,
+            vad: features.vad?.enabled || false,
+            asr: features.asr?.enabled || false
+        };
+    }
+
+    /**
+     * 获取指定功能的状态
+     */
+    getFeatureStatus(featureKey) {
+        const features = this.getAllFeatures();
+        return features[featureKey]?.enabled || false;
+    }
+
+    /**
+     * 设置功能状态
+     */
+    setFeatureStatus(featureKey, enabled) {
+        const features = this.getAllFeatures();
+        if (features[featureKey]) {
+            features[featureKey].enabled = enabled;
+            this.saveConfig(features);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * 启用功能
+     */
+    enableFeature(featureKey) {
+        return this.setFeatureStatus(featureKey, true);
+    }
+
+    /**
+     * 禁用功能
+     */
+    disableFeature(featureKey) {
+        return this.setFeatureStatus(featureKey, false);
+    }
+
+    /**
+     * 切换功能状态
+     */
+    toggleFeature(featureKey) {
+        const currentStatus = this.getFeatureStatus(featureKey);
+        return this.setFeatureStatus(featureKey, !currentStatus);
+    }
+
+    /**
+     * 重置所有功能为默认状态
+     */
+    resetToDefault() {
+        this.saveConfig(this.defaultFeatures);
+    }
+
+    /**
+     * 批量更新功能状态
+     */
+    updateFeatures(featureUpdates) {
+        const features = this.getAllFeatures();
+        Object.keys(featureUpdates).forEach(featureKey => {
+            if (features[featureKey]) {
+                features[featureKey].enabled = featureUpdates[featureKey];
+            }
+        });
+        this.saveConfig(features);
+    }
+
+    /**
+     * 获取已启用的功能列表
+     */
+    getEnabledFeatures() {
+        const features = this.getAllFeatures();
+        return Object.keys(features).filter(key => features[key].enabled);
+    }
+
+    /**
+     * 检查功能是否启用
+     */
+    isFeatureEnabled(featureKey) {
+        return this.getFeatureStatus(featureKey);
+    }
+}
+
+// 创建单例实例
+const featureManager = new FeatureManager();
+
+export default featureManager;
@@ -35,7 +35,7 @@
              <el-table-column :label="$t('device.bindTime')" prop="bindTime" align="center"></el-table-column>
              <el-table-column :label="$t('device.lastConversation')" prop="lastConversation"
                align="center"></el-table-column>
-              <el-table-column :label="$t('device.deviceStatus')" prop="deviceStatus" align="center">
+              <el-table-column v-if="mqttServiceAvailable" :label="$t('device.deviceStatus')" prop="deviceStatus" align="center">
                <template slot-scope="scope">
                  <el-tag v-if="scope.row.deviceStatus === 'online'" type="success">{{ $t('device.online') }}</el-tag>
                  <el-tag v-else type="danger">{{ $t('device.offline') }}</el-tag>
@@ -147,6 +147,7 @@ export default {
      loading: false,
      userApi: null,
      firmwareTypes: [],
+      mqttServiceAvailable: false, // MQTT服务是否可用
    };
  },
  computed: {
@@ -392,12 +393,21 @@ export default {

            // 直接使用解析后的数据作为设备状态映射（不需要devices字段包装）
            if (statusData && typeof statusData === 'object') {
+              // 成功获取到设备状态
+              this.mqttServiceAvailable = true;
              // 更新设备状态
              this.updateDeviceStatusFromResponse(statusData);
+            } else {
+              // 数据格式不正确，MQTT服务不可用
+              this.mqttServiceAvailable = false;
            }
          } catch (error) {
-            // JSON解析失败，忽略状态更新
+            // JSON解析失败，MQTT服务不可用
+            this.mqttServiceAvailable = false;
          }
+        } else {
+          // 接口调用失败，MQTT服务不可用
+          this.mqttServiceAvailable = false;
        }
      });
    },
@@ -0,0 +1,601 @@
+<template>
+  <div class="welcome">
+    <HeaderBar />
+
+    <div class="operation-bar">
+          <h2 class="page-title">{{ $t('header.featureManagement') }}</h2>
+        </div>
+
+    <div class="main-wrapper">
+      <div class="content-panel">
+        <div class="content-area">
+          <el-card class="feature-card" shadow="never">
+            <div class="config-header">
+              <div class="header-icon">
+                <img loading="lazy" src="@/assets/home/equipment.png" alt="" />
+              </div>
+              <div class="header-actions">
+                <el-button @click="!isSaving && toggleSelectAll()" class="btn-select-all" :disabled="isSaving">
+                  {{ isAllSelected ? $t('featureManagement.deselectAll') : $t('featureManagement.selectAll') }}
+                </el-button>
+                <el-button type="primary" class="save-btn" @click="handleSave" :disabled="isSaving">
+                  {{ isSaving ? $t('featureManagement.saving') : $t('featureManagement.save') }}
+                </el-button>
+                <el-button class="reset-btn" @click="handleReset" :disabled="isSaving">
+                  {{ $t('featureManagement.reset') }}
+                </el-button>
+              </div>
+            </div>
+            <div class="divider"></div>
+            
+            <!-- 功能分组容器 - 左右布局 -->
+            <div class="feature-groups-container">
+              <!-- 功能管理分组 -->
+              <div v-if="featureManagementFeatures.length > 0" class="feature-group">
+                <h3 class="group-title">{{ $t('featureManagement.group.featureManagement') }}</h3>
+                <div class="features-grid">
+                  <div
+                    v-for="feature in featureManagementFeatures"
+                    :key="feature.id"
+                    class="feature-card-item"
+                    :class="{ 'feature-enabled': feature.enabled, 'feature-disabled': isSaving }"
+                    @click="!isSaving && toggleFeature(feature)"
+                  >
+                    <div class="feature-header">
+                      <h3 class="feature-name">{{ $t(`feature.${feature.id}.name`) }}</h3>
+                      <el-checkbox
+                        v-model="feature.enabled"
+                        @change="!isSaving && toggleFeature(feature)"
+                        class="feature-checkbox"
+                        :disabled="isSaving"
+                      />
+                    </div>
+                    <p class="feature-description">{{ $t(`feature.${feature.id}.description`) }}</p>
+                  </div>
+                </div>
+              </div>
+              
+              <!-- 语音管理分组 -->
+              <div v-if="voiceManagementFeatures.length > 0" class="feature-group">
+                <h3 class="group-title">{{ $t('featureManagement.group.voiceManagement') }}</h3>
+                <div class="features-grid">
+                  <div
+                    v-for="feature in voiceManagementFeatures"
+                    :key="feature.id"
+                    class="feature-card-item"
+                    :class="{ 'feature-enabled': feature.enabled, 'feature-disabled': isSaving }"
+                    @click="!isSaving && toggleFeature(feature)"
+                  >
+                    <div class="feature-header">
+                      <h3 class="feature-name">{{ $t(`feature.${feature.id}.name`) }}</h3>
+                      <el-checkbox
+                        v-model="feature.enabled"
+                        @change="!isSaving && toggleFeature(feature)"
+                        class="feature-checkbox"
+                        :disabled="isSaving"
+                      />
+                    </div>
+                    <p class="feature-description">{{ $t(`feature.${feature.id}.description`) }}</p>
+                  </div>
+                </div>
+              </div>
+            </div>
+            
+            <div v-if="filteredFeatures.length === 0" class="empty-state">
+              <el-empty :description="$t('featureManagement.noFeatures')">
+                <p class="empty-tip">{{ $t('featureManagement.contactAdmin') }}</p>
+              </el-empty>
+            </div>
+          </el-card>
+        </div>
+      </div>
+    </div>
+
+    <el-footer>
+      <VersionFooter />
+    </el-footer>
+  </div>
+</template>
+
+<script>
+import HeaderBar from "@/components/HeaderBar.vue";
+import VersionFooter from "@/components/VersionFooter.vue";
+import featureManager from "@/utils/featureManager.js";
+
+export default {
+  name: "FeatureManagement",
+  components: {
+    HeaderBar,
+    VersionFooter
+  },
+  data() {
+    return {
+      pendingChanges: false,
+      featureManagementFeatures: [],
+      voiceManagementFeatures: [],
+      isSaving: false // 添加保存状态锁定
+    }
+  },
+  computed: {
+    // 所有功能列表
+    filteredFeatures() {
+      return [...this.featureManagementFeatures, ...this.voiceManagementFeatures]
+    },
+    
+    // 判断是否所有功能都已选中
+    isAllSelected() {
+      const allFeatures = [...this.featureManagementFeatures, ...this.voiceManagementFeatures]
+      return allFeatures.length > 0 && allFeatures.every(feature => feature.enabled)
+    }
+  },
+  async created() {
+    // 等待功能配置管理器初始化完成
+    try {
+      console.log('等待功能配置管理器初始化...')
+      await featureManager.waitForInitialization()
+      console.log('功能配置管理器初始化完成，开始加载功能配置')
+      await this.loadFeatures()
+      this.setupConfigChangeListener()
+    } catch (error) {
+      console.error('功能配置管理器初始化等待失败:', error)
+      await this.loadFeatures()
+      this.setupConfigChangeListener()
+    }
+  },
+  
+  beforeDestroy() {
+    this.removeConfigChangeListener()
+  },
+  
+  methods: {
+    // 根据ID列表获取功能
+    async getFeaturesByIds(featureIds) {
+      try {
+        const featureConfig = await featureManager.getAllFeatures()
+        console.log('获取到的功能配置:', JSON.stringify(featureConfig, null, 2))
+        console.log('请求的功能ID列表:', featureIds)
+        
+        const result = featureIds.map(id => {
+          const feature = featureConfig[id]
+          console.log(`功能 ${id} 的配置:`, feature)
+          console.log(`功能 ${id} 的启用状态:`, feature?.enabled)
+          
+          return {
+            id: id,
+            name: this.$t(`feature.${id}.name`),
+            description: this.$t(`feature.${id}.description`),
+            enabled: feature?.enabled || false
+          }
+        })
+        
+        console.log('最终返回的功能列表:', JSON.stringify(result, null, 2))
+        return result
+      } catch (error) {
+        console.error('获取功能配置失败:', error)
+        // 如果获取失败，返回默认配置
+        return featureIds.map(id => ({
+          id: id,
+          name: this.$t(`feature.${id}.name`),
+          description: this.$t(`feature.${id}.description`),
+          enabled: false
+        }))
+      }
+    },
+    
+    // 加载功能配置
+    async loadFeatures() {
+      // 保存当前用户的选择状态
+      const currentFeatureStates = {}
+      const allCurrentFeatures = [...this.featureManagementFeatures, ...this.voiceManagementFeatures]
+      allCurrentFeatures.forEach(feature => {
+        currentFeatureStates[feature.id] = feature.enabled
+      })
+      
+      // 重新加载配置
+      this.featureManagementFeatures = await this.getFeaturesByIds(['voiceprintRecognition', 'voiceClone', 'knowledgeBase', 'mcpAccessPoint'])
+      this.voiceManagementFeatures = await this.getFeaturesByIds(['vad', 'asr'])
+      
+      // 恢复用户的选择状态（如果存在）
+      const allFeatures = [...this.featureManagementFeatures, ...this.voiceManagementFeatures]
+      allFeatures.forEach(feature => {
+        if (currentFeatureStates.hasOwnProperty(feature.id)) {
+          feature.enabled = currentFeatureStates[feature.id]
+        }
+      })
+    },
+    // 切换功能状态
+    async toggleFeature(feature) {
+      // 如果正在保存，阻止操作
+      if (this.isSaving) {
+        return
+      }
+      
+      feature.enabled = !feature.enabled
+      this.pendingChanges = true
+      
+      // 不再立即更新到配置管理器，只在保存时统一更新
+    },
+    // 保存配置
+    async handleSave() {
+      if (!this.pendingChanges) {
+        this.$message.info({
+          message: this.$t('featureManagement.noChanges'),
+          showClose: true
+        })
+        return
+      }
+      
+      // 设置保存状态，锁定界面
+      this.isSaving = true
+      
+      try {
+        // 获取当前所有功能的状态并保存
+        const featureUpdates = {}
+        const allFeatures = [...this.featureManagementFeatures, ...this.voiceManagementFeatures]
+        allFeatures.forEach(feature => {
+          featureUpdates[feature.id] = feature.enabled
+        })
+        await featureManager.updateFeatures(featureUpdates)
+        
+        this.pendingChanges = false
+        this.$message.success({
+          message: this.$t('featureManagement.saveSuccess'),
+          showClose: true
+        })
+
+        setTimeout(() => {
+          this.loadFeatures()
+          this.$router.go(0)
+        }, 1000)
+      } catch (error) {
+        console.error('保存配置失败:', error)
+        this.$message.error({
+          message: this.$t('featureManagement.saveError'),
+          showClose: true
+        })
+      } finally {
+        // 无论成功与否，都解除保存状态锁定
+        this.isSaving = false
+      }
+    },
+    // 设置配置变化监听器
+    setupConfigChangeListener() {
+      this.configChangeHandler = () => {
+        console.log('检测到配置变化，重新加载功能列表')
+        this.loadFeatures()
+      }
+      window.addEventListener('featureConfigReloaded', this.configChangeHandler)
+    },
+    
+    // 移除配置变化监听器
+    removeConfigChangeListener() {
+      if (this.configChangeHandler) {
+        window.removeEventListener('featureConfigReloaded', this.configChangeHandler)
+      }
+    },
+    
+    // 重置配置
+    async handleReset() {
+      try {
+        await this.$confirm(
+          this.$t('featureManagement.resetConfirm'),
+          this.$t('featureManagement.reset'),
+          {
+            confirmButtonText: this.$t('featureManagement.confirm'),
+            cancelButtonText: this.$t('featureManagement.cancel'),
+            type: 'warning'
+          }
+        )
+        
+        featureManager.resetToDefault()
+        this.loadFeatures()
+        this.pendingChanges = false
+        
+        this.$message.success({
+          message: this.$t('featureManagement.resetSuccess'),
+          showClose: true
+        })
+        
+        setTimeout(() => {
+          this.loadFeatures()
+          this.$router.go(0)
+        }, 1000)
+      } catch (error) {
+        // 用户取消操作
+      }
+    },
+    // 搜索功能（预留接口）
+    handleSearch() {
+      // 搜索功能待实现
+    },
+    // 全选/取消全选
+    toggleSelectAll() {
+      // 如果正在保存，阻止操作
+      if (this.isSaving) {
+        return
+      }
+      
+      const allFeatures = [...this.featureManagementFeatures, ...this.voiceManagementFeatures]
+      const newStatus = !this.isAllSelected
+      
+      allFeatures.forEach(feature => {
+        feature.enabled = newStatus
+      })
+      
+      this.pendingChanges = true
+    }
+  }
+}
+</script>
+
+<style scoped>
+.welcome {
+  min-width: 900px;
+  min-height: 506px;
+  height: 100vh;
+  display: flex;
+  position: relative;
+  flex-direction: column;
+  background-size: cover;
+  background: linear-gradient(to bottom right, #dce8ff, #e4eeff, #e6cbfd) center;
+  -webkit-background-size: cover;
+  -o-background-size: cover;
+  overflow: hidden;
+}
+
+.operation-bar {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 16px 24px;
+}
+
+.page-title {
+  font-size: 24px;
+  margin: 0;
+}
+
+.config-header {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 0 0 16px 0;
+}
+
+.header-icon {
+  width: 40px;
+  height: 40px;
+  background: #5778ff;
+  border-radius: 50%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  margin-right: 12px;
+}
+
+.header-icon img {
+  width: 20px;
+  height: 20px;
+}
+
+.header-actions {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-left: auto;
+}
+
+.divider {
+  height: 1px;
+  background: #e0e0e0;
+  margin-bottom: 20px;
+}
+
+.btn-select-all {
+  background: #e6ebff;
+  color: #5778ff;
+  border: 1px solid #adbdff;
+  border-radius: 18px;
+  padding: 8px 16px;
+  height: 32px;
+  font-size: 14px;
+}
+
+.btn-select-all:hover {
+  background: #d0d8ff;
+}
+
+.save-btn {
+  background: #5778ff;
+  color: white;
+  border: none;
+  border-radius: 18px;
+  padding: 8px 16px;
+  height: 32px;
+  font-size: 14px;
+}
+
+.save-btn:hover {
+  background: #4a6ae8;
+}
+
+.reset-btn {
+  background: #e6ebff;
+  color: #5778ff;
+  border: 1px solid #adbdff;
+  border-radius: 18px;
+  padding: 8px 16px;
+  height: 32px;
+}
+
+.reset-btn:hover {
+  background: #d0d8ff;
+}
+
+.main-wrapper {
+  margin: 0 22px 5px 22px;
+  border-radius: 15px;
+  min-height: calc(100vh - 24vh);
+  height: auto;
+  max-height: 80vh;
+  box-shadow: 0 2px 12px rgba(0, 0, 0, 0.1);
+  position: relative;
+  background: rgba(237, 242, 255, 0.5);
+  display: flex;
+  flex-direction: column;
+}
+
+.content-panel {
+  flex: 1;
+  display: flex;
+  overflow: hidden;
+  height: 100%;
+  border-radius: 15px;
+  background: transparent;
+  border: 1px solid #fff;
+}
+
+.content-area {
+  flex: 1;
+  height: 100%;
+  min-width: 600px;
+  overflow: auto;
+  background-color: white;
+  display: flex;
+  flex-direction: column;
+}
+
+.feature-card {
+  background: white;
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  border: none;
+  box-shadow: none;
+  overflow: hidden;
+}
+
+.feature-card ::v-deep .el-card__body {
+  padding: 24px;
+  display: flex;
+  flex-direction: column;
+  flex: 1;
+  overflow: hidden;
+}
+
+.features-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+  gap: 16px;
+}
+
+.feature-card-item {
+  display: flex;
+  flex-direction: column;
+  padding: 20px;
+  border-radius: 12px;
+  border: 2px solid #e0e0e0;
+  background-color: white;
+  cursor: pointer;
+  transition: all 0.3s ease;
+  user-select: none;
+  position: relative;
+}
+
+.feature-card-item:hover {
+  border-color: #869bf0;
+  box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+  transform: translateY(-2px);
+}
+
+.feature-card-item.feature-enabled {
+  border-color:#5778ff;
+  box-shadow: 0 4px 16px rgba(95, 112, 243, 0.2);
+  transform: translateY(-2px);
+}
+
+.feature-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 12px;
+}
+
+.feature-checkbox ::v-deep .el-checkbox__input {
+  transform: scale(1.2);
+}
+
+.feature-checkbox ::v-deep .el-checkbox__input.is-checked .el-checkbox__inner {
+  background-color: #5778ff;
+  border-color: #5778ff;
+}
+
+.feature-checkbox ::v-deep .el-checkbox__input.is-checked + .el-checkbox__label {
+  color: #5778ff;
+}
+
+
+.feature-name {
+  font-size: 18px;
+  font-weight: 600;
+  color: #333;
+  margin: 0;
+  transition: color 0.3s ease;
+}
+
+
+.feature-description {
+  font-size: 14px;
+  line-height: 1.6;
+  color: #666;
+  margin: 0 0 12px 0;
+  transition: color 0.3s ease;
+  text-align: left;
+}
+
+
+/* 功能分组容器 - 左右布局 */
+.feature-groups-container {
+  display: flex;
+  gap: 32px;
+  align-items: flex-start;
+  position: relative;
+}
+
+/* 分组之间的分隔线 */
+.feature-groups-container::before {
+  content: '';
+  position: absolute;
+  left: 50%;
+  top: 0;
+  bottom: 0;
+  width: 1px;
+  height: 550px;
+  background: #e0e0e0;
+  opacity: 0.5;
+  transform: translateX(-50%);
+}
+
+/* 分组样式 */
+.feature-group {
+  flex: 1;
+  min-width: 0;
+  margin-bottom: 32px;
+}
+
+.group-title {
+  font-size: 18px;
+  font-weight: 600;
+  color: #303133;
+  margin-bottom: 12px;
+  padding-left: 12px;
+  border-left: 4px solid #5f70f3;
+  text-align: left;
+}
+
+.features-grid {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+  gap: 16px;
+}
+</style>
@@ -214,10 +214,11 @@
    <el-dialog :title="$t('knowledgeFileUpload.retrievalTest')" :visible.sync="retrievalTestDialogVisible"
      width="1200px" class="retrieval-test-dialog">
      <div class="retrieval-test-form">
-        <el-form :model="retrievalTestForm" label-width="80px">
+        <el-form :model="retrievalTestForm" label-width="80px" @submit.native.prevent="runRetrievalTest">
          <el-form-item :label="$t('knowledgeFileUpload.testQuestion')" required>
            <el-input v-model="retrievalTestForm.question"
-              :placeholder="$t('knowledgeFileUpload.testQuestionPlaceholder')" style="width: 100%; max-height: 80px;">
+              :placeholder="$t('knowledgeFileUpload.testQuestionPlaceholder')" style="width: 100%; max-height: 80px;"
+              @keyup.enter.native="runRetrievalTest">
            </el-input>
          </el-form-item>
        </el-form>
@@ -38,11 +38,11 @@
  position: absolute;
  top: 50%;
  transform: translateY(-50%);
-  right: 15%;
+  right: 18%;
  background-color: #fff;
  border-radius: 20px;
  padding: 35px 0;
-  width: 550px;
+  width: 450px;
  box-sizing: border-box;
 }

@@ -39,8 +39,9 @@
          </template>

          <template v-else>
-            <DeviceItem v-for="(item, index) in devices" :key="index" :device="item" @configure="goToRoleConfig"
-              @deviceManage="handleDeviceManage" @delete="handleDeleteAgent" @chat-history="handleShowChatHistory" />
+            <DeviceItem v-for="(item, index) in devices" :key="index" :device="item" :feature-status="featureStatus" 
+              @configure="goToRoleConfig" @deviceManage="handleDeviceManage" @delete="handleDeleteAgent" 
+              @chat-history="handleShowChatHistory" />
          </template>
        </div>
      </div>
@@ -61,6 +62,7 @@ import ChatHistoryDialog from '@/components/ChatHistoryDialog.vue';
 import DeviceItem from '@/components/DeviceItem.vue';
 import HeaderBar from '@/components/HeaderBar.vue';
 import VersionFooter from '@/components/VersionFooter.vue';
+import featureManager from '@/utils/featureManager';

 export default {
  name: 'HomePage',
@@ -76,15 +78,33 @@ export default {
      skeletonCount: localStorage.getItem('skeletonCount') || 8,
      showChatHistory: false,
      currentAgentId: '',
-      currentAgentName: ''
+      currentAgentName: '',
+      // 功能状态
+      featureStatus: {
+        voiceprintRecognition: false,
+        voiceClone: false,
+        knowledgeBase: false
+      }
    }
  },

-  mounted() {
+  async mounted() {
    this.fetchAgentList();
+    await this.loadFeatureStatus();
  },

  methods: {
+    // 加载功能状态
+    async loadFeatureStatus() {
+      await featureManager.waitForInitialization();
+      const config = featureManager.getConfig();
+      this.featureStatus = {
+        voiceprintRecognition: config.voiceprintRecognition,
+        voiceClone: config.voiceClone,
+        knowledgeBase: config.knowledgeBase
+      };
+    },
+    
    showAddDialog() {
      this.addDeviceDialogVisible = true
    },
@@ -10,7 +10,7 @@
            gap: 10px;
          ">
          <img loading="lazy" alt="" src="@/assets/xiaozhi-logo.png" style="width: 45px; height: 45px" />
-          <img loading="lazy" alt="" src="@/assets/xiaozhi-ai.png" style="height: 18px" />
+          <img loading="lazy" alt="" :src="xiaozhiAiIcon" style="height: 18px" />
        </div>
      </el-header>
      <div class="login-person">
@@ -156,6 +156,7 @@ import VersionFooter from "@/components/VersionFooter.vue";
 import i18n, { changeLanguage } from "@/i18n";
 import { getUUID, goToPage, showDanger, showSuccess, sm2Encrypt, validateMobile } from "@/utils";
 import { mapState } from "vuex";
+import featureManager from "@/utils/featureManager";

 export default {
  name: "login",
@@ -191,6 +192,24 @@ export default {
          return this.$t("language.zhCN");
      }
    },
+    // 根据当前语言获取对应的xiaozhi-ai图标
+    xiaozhiAiIcon() {
+      const currentLang = this.currentLanguage;
+      switch (currentLang) {
+        case "zh_CN":
+          return require("@/assets/xiaozhi-ai.png");
+        case "zh_TW":
+          return require("@/assets/xiaozhi-ai_zh_TW.png");
+        case "en":
+          return require("@/assets/xiaozhi-ai_en.png");
+        case "de":
+          return require("@/assets/xiaozhi-ai_de.png");
+        case "vi":
+          return require("@/assets/xiaozhi-ai_vi.png");
+        default:
+          return require("@/assets/xiaozhi-ai.png");
+      }
+    },
  },
  data() {
    return {
@@ -214,6 +233,13 @@ export default {
    this.$store.dispatch("fetchPubConfig").then(() => {
      // 根据配置决定默认登录方式
      this.isMobileLogin = this.enableMobileRegister;
+      
+      // pub-config接口调用完成后，重新初始化featureManager以确保使用最新的配置
+      featureManager.waitForInitialization().then(() => {
+        console.log('featureManager重新初始化完成，使用pub-config配置');
+      }).catch(error => {
+        console.warn('featureManager重新初始化失败:', error);
+      });
    });
  },
  methods: {
@@ -5,7 +5,7 @@
      <el-header>
        <div style="display: flex;align-items: center;margin-top: 15px;margin-left: 10px;gap: 10px;">
          <img loading="lazy" alt="" src="@/assets/xiaozhi-logo.png" style="width: 45px;height: 45px;" />
-          <img loading="lazy" alt="" src="@/assets/xiaozhi-ai.png" style="height: 18px;" />
+          <img loading="lazy" alt="" :src="xiaozhiAiIcon" style="height: 18px;" />
        </div>
      </el-header>
      <div class="login-person">
@@ -108,7 +108,7 @@
          <div style="font-size: 14px;color: #979db1;">
            {{ $t('register.agreeTo') }}
            <div style="display: inline-block;color: #5778FF;cursor: pointer;">{{ $t('register.userAgreement') }}</div>
-            {{ $t('register.and') }}
+            {{ $t('login.and') }}
            <div style="display: inline-block;color: #5778FF;cursor: pointer;">{{ $t('register.privacyPolicy') }}</div>
          </div>
        </div>
@@ -127,6 +127,7 @@ import Api from '@/apis/api';
 import VersionFooter from '@/components/VersionFooter.vue';
 import { getUUID, goToPage, showDanger, showSuccess, sm2Encrypt, validateMobile } from '@/utils';
 import { mapState } from 'vuex';
+import i18n from '@/i18n';

 // 导入语言切换功能

@@ -142,6 +143,28 @@ export default {
      mobileAreaList: state => state.pubConfig.mobileAreaList,
      sm2PublicKey: state => state.pubConfig.sm2PublicKey,
    }),
+    // 获取当前语言
+    currentLanguage() {
+      return i18n.locale || "zh_CN";
+    },
+    // 根据当前语言获取对应的xiaozhi-ai图标
+    xiaozhiAiIcon() {
+      const currentLang = this.currentLanguage;
+      switch (currentLang) {
+        case "zh_CN":
+          return require("@/assets/xiaozhi-ai.png");
+        case "zh_TW":
+          return require("@/assets/xiaozhi-ai_zh_TW.png");
+        case "en":
+          return require("@/assets/xiaozhi-ai_en.png");
+        case "de":
+          return require("@/assets/xiaozhi-ai_de.png");
+        case "vi":
+          return require("@/assets/xiaozhi-ai_vi.png");
+        default:
+          return require("@/assets/xiaozhi-ai.png");
+      }
+    },
    canSendMobileCaptcha() {
      return this.countdown === 0 && validateMobile(this.form.mobile, this.form.areaCode);
    }
@@ -5,7 +5,7 @@
      <el-header>
        <div style="display: flex;align-items: center;margin-top: 15px;margin-left: 10px;gap: 10px;">
          <img loading="lazy" alt="" src="@/assets/xiaozhi-logo.png" style="width: 45px;height: 45px;" />
-          <img loading="lazy" alt="" src="@/assets/xiaozhi-ai.png" style="height: 18px;" />
+          <img loading="lazy" alt="" :src="xiaozhiAiIcon" style="height: 18px;" />
        </div>
      </el-header>
      <div class="login-person">
@@ -83,7 +83,7 @@
            <div style="font-size: 14px;color: #979db1;">
              {{ $t('retrievePassword.agreeTo') }}
              <div style="display: inline-block;color: #5778FF;cursor: pointer;">{{ $t('register.userAgreement') }}</div>
-              {{ $t('register.and') }}
+              {{ $t('login.and') }}
              <div style="display: inline-block;color: #5778FF;cursor: pointer;">{{ $t('register.privacyPolicy') }}</div>
            </div>
          </div>
@@ -103,6 +103,7 @@ import Api from '@/apis/api';
 import VersionFooter from '@/components/VersionFooter.vue';
 import { getUUID, goToPage, showDanger, showSuccess, validateMobile, sm2Encrypt } from '@/utils';
 import { mapState } from 'vuex';
+import i18n from '@/i18n';

 // 导入语言切换功能
 import { changeLanguage } from '@/i18n';
@@ -118,6 +119,28 @@ export default {
      mobileAreaList: state => state.pubConfig.mobileAreaList,
      sm2PublicKey: state => state.pubConfig.sm2PublicKey
    }),
+    // 获取当前语言
+    currentLanguage() {
+      return i18n.locale || "zh_CN";
+    },
+    // 根据当前语言获取对应的xiaozhi-ai图标
+    xiaozhiAiIcon() {
+      const currentLang = this.currentLanguage;
+      switch (currentLang) {
+        case "zh_CN":
+          return require("@/assets/xiaozhi-ai.png");
+        case "zh_TW":
+          return require("@/assets/xiaozhi-ai_zh_TW.png");
+        case "en":
+          return require("@/assets/xiaozhi-ai_en.png");
+        case "de":
+          return require("@/assets/xiaozhi-ai_de.png");
+        case "vi":
+          return require("@/assets/xiaozhi-ai_vi.png");
+        default:
+          return require("@/assets/xiaozhi-ai.png");
+      }
+    },
    canSendMobileCaptcha() {
      return this.countdown === 0 && validateMobile(this.form.mobile, this.form.areaCode);
    }
@@ -55,10 +55,24 @@
                        </div>
                      </div>
                    </el-form-item>
+                    <el-form-item :label="$t('roleConfig.contextProvider') + '：'" class="context-provider-item">
+                      <div style="display: flex; align-items: center; justify-content: space-between;">
+                        <span style="color: #606266; font-size: 13px;">
+                          {{ $t('roleConfig.contextProviderSuccess', { count: currentContextProviders.length }) }}<a href="https://github.com/xinnan-tech/xiaozhi-esp32-server/blob/main/docs/context-provider-integration.md" target="_blank" class="doc-link">{{ $t('roleConfig.contextProviderDocLink') }}</a>
+                        </span>
+                        <el-button
+                          class="edit-function-btn"
+                          size="small"
+                          @click="openContextProviderDialog"
+                        >
+                          {{ $t('roleConfig.editContextProvider') }}
+                        </el-button>
+                      </div>
+                    </el-form-item>
                    <el-form-item :label="$t('roleConfig.roleIntroduction') + '：'">
                      <el-input
                        type="textarea"
-                        rows="9"
+                        rows="8"
                        resize="none"
                        :placeholder="$t('roleConfig.pleaseEnterContent')"
                        v-model="form.systemPrompt"
@@ -71,7 +85,7 @@
                    <el-form-item :label="$t('roleConfig.memoryHis') + '：'">
                      <el-input
                        type="textarea"
-                        rows="6"
+                        rows="4"
                        resize="none"
                        v-model="form.summaryMemory"
                        maxlength="2000"
@@ -107,7 +121,11 @@
                  </div>
                  <div class="form-column">
                    <div class="model-row">
-                      <el-form-item :label="$t('roleConfig.vad')" class="model-item">
+                      <el-form-item 
+                        v-if="featureStatus.vad" 
+                        :label="$t('roleConfig.vad')" 
+                        class="model-item"
+                      >
                        <div class="model-select-wrapper">
                          <el-select
                            v-model="form.model.vadModelId"
@@ -125,7 +143,11 @@
                          </el-select>
                        </div>
                      </el-form-item>
-                      <el-form-item :label="$t('roleConfig.asr')" class="model-item">
+                      <el-form-item 
+                        v-if="featureStatus.asr" 
+                        :label="$t('roleConfig.asr')" 
+                        class="model-item"
+                      >
                        <div class="model-select-wrapper">
                          <el-select
                            v-model="form.model.asrModelId"
@@ -267,6 +289,11 @@
      @update-functions="handleUpdateFunctions"
      @dialog-closed="handleDialogClosed"
    />
+    <context-provider-dialog
+      :visible.sync="showContextProviderDialog"
+      :providers="currentContextProviders"
+      @confirm="handleUpdateContext"
+    />
  </div>
 </template>

@@ -275,14 +302,17 @@ import Api from "@/apis/api";
 import { getServiceUrl } from "@/apis/api";
 import RequestService from "@/apis/httpRequest";
 import FunctionDialog from "@/components/FunctionDialog.vue";
+import ContextProviderDialog from "@/components/ContextProviderDialog.vue";
 import HeaderBar from "@/components/HeaderBar.vue";
 import i18n from "@/i18n";
+import featureManager from "@/utils/featureManager"; 

 export default {
  name: "RoleConfigPage",
-  components: { HeaderBar, FunctionDialog },
+  components: { HeaderBar, FunctionDialog, ContextProviderDialog },
  data() {
    return {
+      showContextProviderDialog: false,
      form: {
        agentCode: "",
        agentName: "",
@@ -320,12 +350,18 @@ export default {
      voiceDetails: {}, // 保存完整的音色信息
      showFunctionDialog: false,
      currentFunctions: [],
+      currentContextProviders: [],
      allFunctions: [],
      originalFunctions: [],
      playingVoice: false,
      isPaused: false,
      currentAudio: null,
      currentPlayingVoiceId: null,
+      // 功能状态
+      featureStatus: {
+        vad: false, // 语言检测活动功能状态
+        asr: false, // 语音识别功能状态
+      },
    };
  },
  methods: {
@@ -356,6 +392,7 @@ export default {
            paramInfo: item.params,
          };
        }),
+        contextProviders: this.currentContextProviders,
      };
      Api.agent.updateAgentConfig(this.$route.query.agentId, configData, ({ data }) => {
        if (data.code === 0) {
@@ -472,6 +509,9 @@ export default {
          };
          // 后端只给了最小映射：[{ id, agentId, pluginId }, ...]
          const savedMappings = data.data.functions || [];
+          
+          // 加载上下文配置
+          this.currentContextProviders = data.data.contextProviders || [];

          // 先保证 allFunctions 已经加载（如果没有，则先 fetchAllFunctions）
          const ensureFuncs = this.allFunctions.length
@@ -604,15 +644,14 @@ export default {
      if (type === "Intent" && value !== "Intent_nointent") {
        this.fetchAllFunctions();
      }
-      if (type === "Memory" && value === "Memory_nomem") {
-        this.form.chatHistoryConf = 0;
-      }
-      if (
-        type === "Memory" &&
-        value !== "Memory_nomem" &&
-        (this.form.chatHistoryConf === 0 || this.form.chatHistoryConf === null)
-      ) {
-        this.form.chatHistoryConf = 2;
+      if (type === "Memory") {
+        if (value === "Memory_nomem") {
+          // 无记忆功能的模型，默认不记录聊天记录
+          this.form.chatHistoryConf = 0;
+        } else {
+          // 有记忆功能的模型，默认记录文本和语音
+          this.form.chatHistoryConf = 2;
+        }
      }
      if (type === "LLM") {
        // 当LLM类型改变时，更新意图识别选项的可见性
@@ -647,6 +686,12 @@ export default {
        this.showFunctionDialog = true;
      }
    },
+    openContextProviderDialog() {
+      this.showContextProviderDialog = true;
+    },
+    handleUpdateContext(providers) {
+      this.currentContextProviders = providers;
+    },
    handleUpdateFunctions(selected) {
      this.currentFunctions = selected;
    },
@@ -981,6 +1026,19 @@ export default {
        this.form.chatHistoryConf = 0;
      }
    },
+    // 加载功能状态
+    async loadFeatureStatus() {
+      try {
+        // 确保featureManager已初始化完成
+        await featureManager.waitForInitialization();
+        const config = featureManager.getConfig();
+        this.featureStatus.voiceprintRecognition = config.voiceprintRecognition || false;
+        this.featureStatus.vad = config.vad || false;
+        this.featureStatus.asr = config.asr || false;
+      } catch (error) {
+        console.error("加载功能状态失败:", error);
+      }
+    },
  },
  watch: {
    "form.model.ttsModelId": {
@@ -1003,7 +1061,7 @@ export default {
      immediate: true,
    },
  },
-  mounted() {
+  async mounted() {
    const agentId = this.$route.query.agentId;
    if (agentId) {
      this.fetchAgentConfig(agentId);
@@ -1011,6 +1069,8 @@ export default {
    }
    this.fetchModelOptions();
    this.fetchTemplates();
+    // 加载功能状态，确保featureManager已初始化
+    await this.loadFeatureStatus();
  },
 };
 </script>
@@ -1170,7 +1230,8 @@ export default {

 .template-item {
  height: 4vh;
-  width: 76px;
+  min-width: 60px;
+  padding: 0 12px;
  border-radius: 8px;
  background: #e6ebff;
  line-height: 4vh;
@@ -1180,6 +1241,7 @@ export default {
  color: #5778ff;
  cursor: pointer;
  transition: background-color 0.3s ease;
+  white-space: nowrap;
 }

 .template-item:hover {
@@ -1297,6 +1359,26 @@ export default {
  justify-content: flex-end;
 }

+.chat-history-options ::v-deep .el-radio-button {
+  border-color: #5778ff;
+}
+
+.chat-history-options ::v-deep .el-radio-button .el-radio-button__inner {
+  color: #5778ff;
+  border-color: #5778ff;
+  background-color: transparent;
+}
+
+.chat-history-options ::v-deep .el-radio-button.is-active .el-radio-button__inner {
+  background-color: #5778ff;
+  border-color: #5778ff;
+  color: white;
+}
+
+.chat-history-options ::v-deep .el-radio-button .el-radio-button__inner:hover {
+  color: #5778ff;
+}
+
 .header-actions {
  display: flex;
  align-items: center;
@@ -1344,4 +1426,18 @@ export default {
  height: 32px;
  margin-left: 8px;
 }
+
+.context-provider-item ::v-deep .el-form-item__label {
+  line-height: 42px !important;
+}
+
+.doc-link {
+  color: #5778ff;
+  text-decoration: none;
+  margin-left: 4px;
+
+  &:hover {
+    text-decoration: underline;
+  }
+}
 </style>
@@ -56,6 +56,7 @@
  3. **洞察需求：** 结合上下文**深入理解用户真实意图**后再决定调用，避免无意义调用。
  4. **独立任务：** 除`<context>`已涵盖信息外，用户每个要求（即使相似）都视为**独立任务**，需调用工具获取最新数据，**不可偷懒复用历史结果**。
  5. **不确定时：** **切勿猜测或编造答案**。若不确定相关操作，可引导用户澄清或告知能力限制。
+  6. **多工具调用：** 当用户要求执行多个任务时，你会调用多个工具（数量不定）。**重要：在获取到所有工具结果后，你必须依次总结每个工具的查询结果**，不要遗漏任何一个。例如用户问"设备当前状态，某某地方的天气和社会新闻"，你要先说设备状态，再说天气情况，最后说新闻内容。
 - **重要例外（无需调用）：**
  - `查询"现在的时间"、"今天的日期/星期几"、"今天农历"、"{{local_address}}的天气/未来天气"` -> **直接使用`<context>`信息回复**。
 - **需要调用的情况（示例）：**
@@ -73,6 +74,7 @@
 - **今天农历：** {{lunar_date}}
 - **用户所在城市：** {{local_address}}
 - **当地未来7天天气：** {{weather_info}}
+{{ dynamic_context }}
 </context>

 <memory>
@@ -3,12 +3,13 @@ import uuid
 import signal
 import asyncio
 from aioconsole import ainput
-from config.settings import load_config
+from config.config_loader import load_config
 from config.logger import setup_logging
 from core.utils.util import get_local_ip, validate_mcp_endpoint
 from core.http_server import SimpleHttpServer
-from core.websocket_server import WebSocketServer
+from core.xiaozhi_server_facade import XiaozhiServerFacade
 from core.utils.util import check_ffmpeg_installed
+from core.utils.gc_manager import get_gc_manager

 TAG = __name__
 logger = setup_logging()
@@ -63,9 +64,13 @@ async def main():
    # 添加 stdin 监控任务
    stdin_task = asyncio.create_task(monitor_stdin())

-    # 启动 WebSocket 服务器
-    ws_server = WebSocketServer(config)
-    ws_task = asyncio.create_task(ws_server.start())
+    # 启动全局GC管理器（5分钟清理一次）
+    gc_manager = get_gc_manager(interval_seconds=300)
+    await gc_manager.start()
+
+    # 启动小智服务器门面（支持WebSocket和MQTT）
+    xiaozhi_server = XiaozhiServerFacade(config)
+    xiaozhi_task = asyncio.create_task(xiaozhi_server.start())
    # 启动 Simple http 服务器
    ota_server = SimpleHttpServer(config)
    ota_task = asyncio.create_task(ota_server.start())
@@ -95,24 +100,52 @@ async def main():
            logger.bind(tag=TAG).error("mcp接入点不符合规范")
            config["mcp_endpoint"] = "你的接入点 websocket地址"

-    # 获取WebSocket配置，使用安全的默认值
-    websocket_port = 8000
-    server_config = config.get("server", {})
-    if isinstance(server_config, dict):
-        websocket_port = int(server_config.get("port", 8000))
-
-    logger.bind(tag=TAG).info(
-        "Websocket地址是\tws://{}:{}/xiaozhi/v1/",
-        get_local_ip(),
-        websocket_port,
-    )
-
-    logger.bind(tag=TAG).info(
-        "=======上面的地址是websocket协议地址，请勿用浏览器访问======="
-    )
-    logger.bind(tag=TAG).info(
-        "如想测试websocket请用谷歌浏览器打开test目录下的test_page.html"
-    )
+    # 显示协议连接信息
+    connection_info = xiaozhi_server.get_connection_info()
+    
+    # WebSocket信息
+    websocket_info = connection_info.get('websocket', {})
+    if websocket_info.get('enabled', False):
+        websocket_port = websocket_info.get('port', 8000)
+        logger.bind(tag=TAG).info(
+            "WebSocket地址是\tws://{}:{}/xiaozhi/v1/",
+            get_local_ip(),
+            websocket_port,
+        )
+    
+    # MQTT信息
+    mqtt_info = connection_info.get('mqtt', {})
+    if mqtt_info.get('enabled', False):
+        mqtt_port = mqtt_info.get('port', 1883)
+        udp_port = mqtt_info.get('udp_port', 1883)
+        logger.bind(tag=TAG).info(
+            "MQTT地址是\t\tmqtt://{}:{}",
+            get_local_ip(),
+            mqtt_port,
+        )
+        logger.bind(tag=TAG).info(
+            "UDP音频端口是\t{}:{}",
+            get_local_ip(),
+            udp_port,
+        )
+    
+    # 显示启用的协议
+    enabled_protocols = xiaozhi_server.config.get('enabled_protocols', [])
+    logger.bind(tag=TAG).info(f"启用的协议: {', '.join(enabled_protocols)}")
+    
+    if 'websocket' in enabled_protocols:
+        logger.bind(tag=TAG).info(
+            "=======上面的WebSocket地址请勿用浏览器访问======="
+        )
+        logger.bind(tag=TAG).info(
+            "如想测试WebSocket请用谷歌浏览器打开test目录下的test_page.html"
+        )
+    
+    if 'mqtt' in enabled_protocols:
+        logger.bind(tag=TAG).info(
+            "=======MQTT客户端ID格式: GID_test@@@mac_address@@@uuid======="
+        )
+    
    logger.bind(tag=TAG).info(
        "=============================================================\n"
    )
@@ -122,15 +155,28 @@ async def main():
    except asyncio.CancelledError:
        print("任务被取消，清理资源中...")
    finally:
+        # 停止小智服务器
+        try:
+            await xiaozhi_server.stop()
+        except Exception as e:
+            logger.bind(tag=TAG).error(f"停止小智服务器失败: {e}")
+        
+        # 停止全局GC管理器
+        await gc_manager.stop()
+
        # 取消所有任务（关键修复点）
        stdin_task.cancel()
-        ws_task.cancel()
+        xiaozhi_task.cancel()
        if ota_task:
            ota_task.cancel()

        # 等待任务终止（必须加超时）
+        tasks_to_wait = [stdin_task, xiaozhi_task]
+        if ota_task:
+            tasks_to_wait.append(ota_task)
+            
        await asyncio.wait(
-            [stdin_task, ws_task, ota_task] if ota_task else [stdin_task, ws_task],
+            tasks_to_wait,
            timeout=3.0,
            return_when=asyncio.ALL_COMPLETED,
        )
@@ -31,16 +31,70 @@ server:
  auth:
    # 是否启用认证
    enabled: false
+    # 设备的token，可以在编译固件的环节，写入你自己定义的token
+    # 固件上的token和以下的token如果能对应，才能连接本服务端
+    tokens:
+      - token: "your-token1" # 设备1的token
+        name: "your-device-name1"  # 设备1标识
+      - token: "your-token2"  # 设备2的token
+        name: "your-device-name2" # 设备2标识
    # 白名单设备ID列表
    # 如果属于白名单内的设备，不校验token，直接放行
    allowed_devices:
      - "11:22:33:44:55:66"
- # MQTT网关配置，用于通过OTA下发到设备，根据mqtt_gateway的.env文件配置，格式为host:port
+  # MQTT网关配置，用于通过OTA下发到设备，根据mqtt_gateway的.env文件配置，格式为host:port
  mqtt_gateway: null
  # MQTT签名密钥，用于生成MQTT连接密码，根据mqtt_gateway的.env文件配置
  mqtt_signature_key: null
  # UDP网关配置
  udp_gateway: null
+
+# #####################################################################################
+# #############################协议配置（Protocol Configuration）########################
+# 支持WebSocket和MQTT两种协议，可以单独启用或同时启用
+protocols:
+  # 启用的协议列表，可选值: ["websocket", "mqtt"]
+  enabled_protocols: ["websocket"]  # 默认只启用WebSocket
+  # WebSocket协议开关
+  websocket_enabled: true
+  # MQTT协议开关
+  mqtt_enabled: false
+
+# MQTT服务器配置（仅在mqtt_enabled为true时生效）
+mqtt_server:
+  # 是否启用MQTT服务器
+  enabled: false
+  # MQTT服务器监听地址
+  host: 0.0.0.0
+  # MQTT服务器端口
+  port: 1883
+  # UDP音频传输端口（通常与MQTT端口相同）
+  udp_port: 1883
+  # 公网IP地址（用于UDP音频传输配置）
+  # 如果使用docker部署或公网部署，请设置为实际的公网IP或域名
+  public_ip: localhost
+  # 最大连接数
+  max_connections: 1000
+  # 心跳检查间隔（秒）
+  heartbeat_interval: 30
+  # 最大消息载荷大小（字节）
+  max_payload_size: 8192
+
+# MQTT协议使用说明：
+# 1. 客户端ID格式：GID_test@@@mac_address@@@uuid 或 GID_test@@@mac_address
+#    例如：GID_test@@@aa:bb:cc:dd:ee:ff@@@unique_uuid_123
+# 2. 连接地址：mqtt://your.server.ip:1883
+# 3. 音频传输：通过UDP加密传输，配置信息在hello消息中返回
+# 4. 消息格式：JSON格式，支持hello、音频、文本等消息类型
+# 
+# 启用MQTT的配置示例：
+# protocols:
+#   enabled_protocols: ["websocket", "mqtt"]  # 同时启用两种协议
+#   mqtt_enabled: true
+# mqtt_server:
+#   enabled: true
+#   port: 1883
+#   public_ip: "your.server.ip"  # 替换为实际IP
 log:
  # 设置控制台输出的日志格式，时间、日志级别、标签、消息
  log_format: "<green>{time:YYMMDD HH:mm:ss}</green>[{version}_{selected_module}][<light-blue>{extra[tag]}</light-blue>]-<level>{level}</level>-<light-green>{message}</light-green>"
@@ -69,6 +123,9 @@ enable_greeting: true
 enable_stop_tts_notify: false
 # 说完话是否开启提示音，音效地址
 stop_tts_notify_voice: "config/assets/tts_notify.mp3"
+# 是否启用WebSocket心跳保活机制
+enable_websocket_ping: false
+

 # TTS音频发送延迟配置
 # tts_audio_send_delay: 控制音频包发送间隔
@@ -113,6 +170,15 @@ wakeup_words:
 # MCP接入点地址，地址格式为：ws://你的mcp接入点ip或者域名:端口号/mcp/?token=你的token
 # 详细教程 https://github.com/xinnan-tech/xiaozhi-esp32-server/blob/main/docs/mcp-endpoint-integration.md
 mcp_endpoint: 你的接入点 websocket地址
+
+# 上下文源配置
+# 用于在系统提示词中注入动态数据，如健康数据、股票信息等
+# 可以添加多个上下文源
+context_providers:
+  - url: ""
+    headers:
+      Authorization: ""
+
 # 插件的基础配置
 plugins:
  # 获取天气插件的配置，这里填写你的api_key
@@ -273,12 +339,15 @@ Memory:
    # 如果这里不填，则会默认使用selected_module.LLM的模型作为意图识别的思考模型
    # 如果你的不想使用selected_module.LLM记忆存储，这里最好使用独立的LLM作为意图识别，例如使用免费的ChatGLMLLM
    llm: ChatGLMLLM
-
 ASR:
  FunASR:
    type: fun_local
    model_dir: models/SenseVoiceSmall
    output_dir: tmp/
+    # 队列最大大小（可选，默认100）
+    # 当并发请求超过此值时，会返回"服务繁忙"提示
+    # 建议根据服务器性能调整，GPU 服务器可适当增大
+    queue_max_size: 100
  FunASRServer:
    # 独立部署FunASR，使用FunASR的API服务，只需要五句话
    # 第一句：mkdir -p ./funasr-runtime-resources/models
@@ -334,6 +403,8 @@ ASR:
    # 热词、替换词使用流程：https://www.volcengine.com/docs/6561/155738
    boosting_table_name: （选填）你的热词文件名称
    correct_table_name: （选填）你的替换词文件名称
+    # 静音判定时长(ms)，默认200ms
+    end_window_size: 200
    output_dir: tmp/
  TencentASR:
    # token申请地址：https://console.cloud.tencent.com/cam/capi
@@ -462,7 +533,6 @@ ASR:
    domain: slm # 识别领域，iat:日常用语，medical:医疗，finance:金融等
    language: zh_cn # 语言，zh_cn:中文，en_us:英文
    accent: mandarin # 方言，mandarin:普通话
-    dwa: wpgs # 动态修正，wpgs:实时返回中间结果
    # 调整音频处理参数以提高长语音识别质量
    output_dir: tmp/
  
@@ -487,7 +557,6 @@ LLM:
    temperature: 0.7  # 温度值
    max_tokens: 500   # 最大生成token数
    top_p: 1
-    top_k: 50
    frequency_penalty: 0  # 频率惩罚
  AliAppLLM:
    # 定义LLM API类型
@@ -670,6 +739,8 @@ TTS:
    access_token: 你的火山引擎语音合成服务access_token
    resource_id: volc.service_type.10029
    speaker: zh_female_wanwanxiaohe_moon_bigtts
+    # 开启WebSocket连接复用，默认复用（注意：复用后设备处于聆听状态时空闲链接会占并发数）
+    enable_ws_reuse: True
    speech_rate: 0
    loudness_rate: 0
    pitch: 0
@@ -1,8 +1,229 @@
 import os
 import yaml
 from collections.abc import Mapping
+from typing import Any, Dict, Optional, Type, TypeVar, Union, get_type_hints, get_origin, get_args
+from dataclasses import dataclass, field, fields, MISSING
+import inspect
 from config.manage_api_client import init_service, get_server_config, get_agent_models

+T = TypeVar('T')
+
+
+class ConfigDict(dict):
+    """增强的配置字典，支持点号访问和嵌套获取"""
+    
+    def __init__(self, data: Dict[str, Any] = None):
+        super().__init__()
+        if data:
+            for key, value in data.items():
+                if isinstance(value, dict):
+                    self[key] = ConfigDict(value)
+                else:
+                    self[key] = value
+    
+    def __getattr__(self, key: str) -> Any:
+        """支持点号访问"""
+        try:
+            return self[key]
+        except KeyError:
+            raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{key}'")
+    
+    def __setattr__(self, key: str, value: Any) -> None:
+        """支持点号设置"""
+        self[key] = value
+    
+    def __getitem__(self, key: str) -> Any:
+        """重写[]访问，支持嵌套路径，找不到抛出KeyError"""
+        if '.' in key:
+            keys = key.split('.')
+            current = self
+            for k in keys:
+                if not isinstance(current, (dict, ConfigDict)):
+                    raise KeyError(f"Cannot access '{k}' on non-dict object")
+                current = super(ConfigDict, current).__getitem__(k)
+            return current
+        return super().__getitem__(key)
+    
+    def get(self, key: str, default: Any = None) -> Any:
+        """重写get方法，支持嵌套路径"""
+        try:
+            return self[key]
+        except KeyError:
+            return default
+    
+    def __setitem__(self, key: str, value: Any) -> None:
+        """重写[]设置，支持嵌套路径"""
+        if '.' in key:
+            keys = key.split('.')
+            current = self
+            for k in keys[:-1]:
+                if k not in current:
+                    current[k] = ConfigDict()
+                elif not isinstance(current[k], (dict, ConfigDict)):
+                    current[k] = ConfigDict()
+                current = current[k]
+            
+            if isinstance(value, dict) and not isinstance(value, ConfigDict):
+                value = ConfigDict(value)
+            super(ConfigDict, current).__setitem__(keys[-1], value)
+        else:
+            if isinstance(value, dict) and not isinstance(value, ConfigDict):
+                value = ConfigDict(value)
+            super().__setitem__(key, value)
+
+
+class ConfigField:
+    """配置字段，模仿dataclass的field功能"""
+    
+    def __init__(self, default=MISSING, default_factory=MISSING, prefix: str = None):
+        self.default = default
+        self.default_factory = default_factory
+        self.prefix = prefix
+        
+        if default is not MISSING and default_factory is not MISSING:
+            raise ValueError("Cannot specify both default and default_factory")
+
+
+def config_field(default=MISSING, default_factory=MISSING, prefix: str = None):
+    """创建配置字段"""
+    return ConfigField(default, default_factory, prefix)
+
+
+def _is_config_class(cls: Type) -> bool:
+    """检查类是否是ConfigurationProperties装饰的配置类"""
+    return hasattr(cls, '_config_prefix') and hasattr(cls, '_inject_config')
+
+
+def _create_nested_config_instance(config_class: Type, config: ConfigDict, config_path: str):
+    """创建嵌套配置类实例"""
+    try:
+        # 获取嵌套配置数据 - 直接传递整个config，让嵌套类自己处理前缀
+        # 因为嵌套类有自己的prefix，它会从config中正确提取数据
+        return config_class(config)
+    except Exception as e:
+        # 如果创建失败，返回None或抛出更详细的错误
+        raise ValueError(f"Failed to create nested config instance for {config_class.__name__} at path '{config_path}': {e}")
+
+
+def ConfigurationProperties(prefix: str = "", auto_inject: bool = True):
+    """
+    配置属性装饰器，模仿Spring Boot的@ConfigurationProperties
+    
+    Args:
+        prefix: 配置前缀，如 'server.database'
+        auto_inject: 是否自动注入配置
+    """
+    def decorator(cls: Type[T]) -> Type[T]:
+        if not inspect.isclass(cls):
+            raise TypeError("ConfigurationProperties can only be applied to classes")
+        
+        # 保存原始的__init__方法
+        original_init = cls.__init__ if hasattr(cls, '__init__') else None
+        
+        # 获取类的类型注解
+        type_hints = get_type_hints(cls)
+        
+        def new_init(self, config: ConfigDict = None, **kwargs):
+            # 如果有原始的__init__，先调用它
+            if original_init and original_init is not object.__init__:
+                try:
+                    original_init(self)
+                except TypeError:
+                    # 如果原始__init__不接受参数，忽略
+                    pass
+            
+            if config is None:
+                # 如果没有传入config，尝试从全局获取
+                config = getattr(self.__class__, '_global_config', None)
+                if config is None:
+                    return
+            
+            # 注入配置
+            self._inject_config(config, prefix, **kwargs)
+        
+        def _inject_config(self, config: ConfigDict, config_prefix: str = "", **overrides):
+            """注入配置到实例属性"""
+            # 处理类属性
+            for attr_name in dir(self.__class__):
+                if attr_name.startswith('_'):
+                    continue
+                    
+                attr_value = getattr(self.__class__, attr_name)
+                if isinstance(attr_value, ConfigField):
+                    # 确定配置路径
+                    field_prefix = attr_value.prefix or config_prefix
+                    config_path = f"{field_prefix}.{attr_name}" if field_prefix else attr_name
+                    
+                    # 从overrides或config获取值
+                    if attr_name in overrides:
+                        value = overrides[attr_name]
+                    else:
+                        # 检查是否有类型注解，如果是嵌套配置类则特殊处理
+                        attr_type = type_hints.get(attr_name)
+                        if attr_type and inspect.isclass(attr_type) and _is_config_class(attr_type):
+                            # 嵌套配置类，创建实例
+                            try:
+                                value = _create_nested_config_instance(attr_type, config, config_path)
+                            except ValueError as e:
+                                # 如果创建失败，使用默认值
+                                print(f"Warning: {e}")
+                                if attr_value.default_factory is not MISSING:
+                                    value = attr_value.default_factory()
+                                else:
+                                    value = attr_value.default
+                        else:
+                            # 普通类型，使用默认值逻辑
+                            if attr_value.default_factory is not MISSING:
+                                default_val = attr_value.default_factory()
+                            else:
+                                default_val = attr_value.default
+                            
+                            value = config.get(config_path, default_val)
+                    
+                    setattr(self, attr_name, value)
+            
+            # 处理类型注解的属性
+            for attr_name, attr_type in type_hints.items():
+                if hasattr(self, attr_name):
+                    continue  # 已经通过ConfigField处理过了
+                
+                config_path = f"{config_prefix}.{attr_name}" if config_prefix else attr_name
+                
+                if attr_name in overrides:
+                    value = overrides[attr_name]
+                else:
+                    # 检查是否是嵌套的ConfigurationProperties类
+                    if inspect.isclass(attr_type) and _is_config_class(attr_type):
+                        # 创建嵌套配置类实例
+                        try:
+                            value = _create_nested_config_instance(attr_type, config, config_path)
+                        except ValueError as e:
+                            # 如果创建失败，使用None或默认值
+                            print(f"Warning: {e}")
+                            value = None
+                    else:
+                        # 普通类型，直接从配置获取
+                        value = config.get(config_path)
+                
+                if value is not None:
+                    setattr(self, attr_name, value)
+        
+        # 添加方法到类
+        cls.__init__ = new_init
+        cls._inject_config = _inject_config
+        cls._config_prefix = prefix
+        
+        # 添加类方法用于设置全局配置
+        @classmethod
+        def set_global_config(cls, config: ConfigDict):
+            cls._global_config = config
+        
+        cls.set_global_config = set_global_config
+        
+        return cls
+    
+    return decorator
+

 def get_project_dir():
    """获取项目根目录"""
@@ -22,6 +243,9 @@ def load_config():
    # 检查缓存
    cached_config = cache_manager.get(CacheType.CONFIG, "main_config")
    if cached_config is not None:
+        # 确保返回的是ConfigDict类型
+        if not isinstance(cached_config, ConfigDict):
+            cached_config = ConfigDict(cached_config)
        return cached_config

    default_config_path = get_project_dir() + "config.yaml"
@@ -32,10 +256,23 @@ def load_config():
    custom_config = read_config(custom_config_path)

    if custom_config.get("manager-api", {}).get("url"):
-        config = get_config_from_api(custom_config)
+        import asyncio
+        try:
+            loop = asyncio.get_running_loop()
+            # 如果已经在事件循环中，使用异步版本
+            config = asyncio.run_coroutine_threadsafe(
+                get_config_from_api_async(custom_config), loop
+            ).result()
+        except RuntimeError:
+            # 如果不在事件循环中（启动时），创建新的事件循环
+            config = asyncio.run(get_config_from_api_async(custom_config))
    else:
        # 合并配置
        config = merge_configs(default_config, custom_config)
+    
+    # 转换为ConfigDict
+    config = ConfigDict(config)
+    
    # 初始化目录
    ensure_directories(config)

@@ -44,13 +281,13 @@ def load_config():
    return config


-def get_config_from_api(config):
-    """从Java API获取配置"""
+async def get_config_from_api_async(config):
+    """从Java API获取配置（异步版本）"""
    # 初始化API客户端
    init_service(config)

    # 获取服务器配置
-    config_data = get_server_config()
+    config_data = await get_server_config()
    if config_data is None:
        raise Exception("Failed to fetch server config from API")

@@ -59,6 +296,7 @@ def get_config_from_api(config):
        "url": config["manager-api"].get("url", ""),
        "secret": config["manager-api"].get("secret", ""),
    }
+    auth_enabled = config_data.get("server", {}).get("auth", {}).get("enabled", False)
    # server的配置以本地为准
    if config.get("server"):
        config_data["server"] = {
@@ -68,15 +306,16 @@ def get_config_from_api(config):
            "vision_explain": config["server"].get("vision_explain", ""),
            "auth_key": config["server"].get("auth_key", ""),
        }
+    config_data["server"]["auth"] = {"enabled": auth_enabled}
    # 如果服务器没有prompt_template，则从本地配置读取
    if not config_data.get("prompt_template"):
        config_data["prompt_template"] = config.get("prompt_template")
-    return config_data
+    return ConfigDict(config_data)


-def get_private_config_from_api(config, device_id, client_id):
+async def get_private_config_from_api(config, device_id, client_id):
    """从Java API获取私有配置"""
-    return get_agent_models(device_id, client_id, config["selected_module"])
+    return await get_agent_models(device_id, client_id, config["selected_module"])


 def ensure_directories(config):
@@ -149,3 +388,218 @@ def merge_configs(default_config, custom_config):
            merged[key] = value

    return merged
+
+
+# 导出主要的类和函数
+__all__ = [
+    'ConfigDict', 
+    'ConfigField', 
+    'config_field', 
+    'ConfigurationProperties',
+    'load_config',
+    'get_project_dir',
+    'merge_configs'
+]
+
+
+# 配置类定义
+
+@ConfigurationProperties(prefix="server.database")
+class DatabaseConfig:
+    """数据库配置类"""
+    host: str = config_field(default="localhost")
+    port: int = config_field(default=3306)
+    username: str = config_field(default="root")
+    password: str = config_field(default="")
+    database: str = config_field(default="xiaozhi")
+
+
+@ConfigurationProperties(prefix="server.redis")
+class RedisConfig:
+    """Redis配置类"""
+    host: str = config_field(default="localhost")
+    port: int = config_field(default=6379)
+    password: str = config_field(default="")
+    db: int = config_field(default=0)
+
+
+@ConfigurationProperties(prefix="mqtt_server")
+class MQTTServerConfig:
+    """MQTT服务器配置类"""
+    enabled: bool = config_field(default=False)
+    host: str = config_field(default="0.0.0.0")
+    port: int = config_field(default=1883)
+    udp_port: int = config_field(default=1883)
+    public_ip: str = config_field(default="localhost")
+    max_connections: int = config_field(default=1000)
+    heartbeat_interval: int = config_field(default=30)
+    max_payload_size: int = config_field(default=8192)
+
+
+@ConfigurationProperties(prefix="server")
+class ServerConfig:
+    """服务器配置类"""
+    ip: str = config_field(default="0.0.0.0")
+    port: int = config_field(default=8080)
+    http_port: int = config_field(default=8081)
+    auth_key: str = config_field(default="")
+    vision_explain: str = config_field(default="")
+    
+    # 嵌套配置类
+    database: DatabaseConfig = config_field(default_factory=lambda: DatabaseConfig())
+    redis: RedisConfig = config_field(default_factory=lambda: RedisConfig())
+    mqtt_server: MQTTServerConfig = config_field(default_factory=lambda: MQTTServerConfig())
+
+
+@ConfigurationProperties(prefix="asr.whisper")
+class WhisperConfig:
+    """Whisper ASR配置类"""
+    model: str = config_field(default="base")
+    language: str = config_field(default="zh")
+    device: str = config_field(default="cpu")
+
+
+@ConfigurationProperties(prefix="asr")
+class ASRConfig:
+    """ASR配置类"""
+    provider: str = config_field(default="whisper")
+    # 嵌套配置
+    whisper: WhisperConfig = config_field(default_factory=lambda: WhisperConfig())
+
+
+@ConfigurationProperties(prefix="selected_module")
+class SelectedModuleConfig:
+    """选中模块配置类"""
+    ASR: str = config_field(default="")
+    TTS: str = config_field(default="")
+    LLM: str = config_field(default="")
+    VLLM: str = config_field(default="")
+    VAD: str = config_field(default="")
+    Memory: str = config_field(default="")
+    Intent: str = config_field(default="")
+
+
+@ConfigurationProperties(prefix="log")
+class LogConfig:
+    """日志配置类"""
+    log_dir: str = config_field(default="tmp")
+    level: str = config_field(default="INFO")
+
+
+@ConfigurationProperties(prefix="protocols")
+class ProtocolConfig:
+    """协议配置类"""
+    enabled_protocols: list = config_field(default_factory=lambda: ["websocket"])
+    websocket_enabled: bool = config_field(default=True)
+    mqtt_enabled: bool = config_field(default=False)
+
+
+@ConfigurationProperties(prefix="")
+class MainConfig:
+    """主配置类，包含常用的顶级配置"""
+    read_config_from_api: bool = config_field(default=False)
+    exit_commands: list = config_field(default_factory=list)
+    close_connection_no_voice_time: int = config_field(default=120)
+    xiaozhi: str = config_field(default="")
+    prompt: str = config_field(default="")
+    delete_audio: bool = config_field(default=True)
+    
+    # 协议配置
+    protocols: ProtocolConfig = config_field(default_factory=lambda: ProtocolConfig())
+
+
+@ConfigurationProperties(prefix="voiceprint")
+class VoiceprintConfig:
+    """声纹配置类"""
+    enabled: bool = config_field(default=False)
+    model_path: str = config_field(default="")
+    threshold: float = config_field(default=0.5)
+
+
+# 全局配置实例
+_global_config_dict: ConfigDict = None
+_server_config: ServerConfig = None
+_selected_module_config: SelectedModuleConfig = None
+_log_config: LogConfig = None
+_main_config: MainConfig = None
+_voiceprint_config: VoiceprintConfig = None
+_mqtt_server_config: MQTTServerConfig = None
+_protocol_config: ProtocolConfig = None
+
+
+def get_config_instance(config_class: Type[T]) -> T:
+    """获取配置类实例的工厂方法"""
+    global _global_config_dict
+    if _global_config_dict is None:
+        _global_config_dict = load_config()
+    
+    return config_class(_global_config_dict)
+
+
+def get_server_config() -> ServerConfig:
+    """获取服务器配置实例"""
+    global _server_config
+    if _server_config is None:
+        _server_config = get_config_instance(ServerConfig)
+    return _server_config
+
+
+def get_selected_module_config() -> SelectedModuleConfig:
+    """获取选中模块配置实例"""
+    global _selected_module_config
+    if _selected_module_config is None:
+        _selected_module_config = get_config_instance(SelectedModuleConfig)
+    return _selected_module_config
+
+
+def get_log_config() -> LogConfig:
+    """获取日志配置实例"""
+    global _log_config
+    if _log_config is None:
+        _log_config = get_config_instance(LogConfig)
+    return _log_config
+
+
+def get_main_config() -> MainConfig:
+    """获取主配置实例"""
+    global _main_config
+    if _main_config is None:
+        _main_config = get_config_instance(MainConfig)
+    return _main_config
+
+
+def get_voiceprint_config() -> VoiceprintConfig:
+    """获取声纹配置实例"""
+    global _voiceprint_config
+    if _voiceprint_config is None:
+        _voiceprint_config = get_config_instance(VoiceprintConfig)
+    return _voiceprint_config
+
+
+def get_mqtt_server_config() -> MQTTServerConfig:
+    """获取MQTT服务器配置实例"""
+    global _mqtt_server_config
+    if _mqtt_server_config is None:
+        _mqtt_server_config = get_config_instance(MQTTServerConfig)
+    return _mqtt_server_config
+
+
+def get_protocol_config() -> ProtocolConfig:
+    """获取协议配置实例"""
+    global _protocol_config
+    if _protocol_config is None:
+        _protocol_config = get_config_instance(ProtocolConfig)
+    return _protocol_config
+
+
+def refresh_config():
+    """刷新所有配置实例"""
+    global _global_config_dict, _server_config, _selected_module_config, _log_config, _main_config, _voiceprint_config, _mqtt_server_config, _protocol_config
+    _global_config_dict = None
+    _server_config = None
+    _selected_module_config = None
+    _log_config = None
+    _main_config = None
+    _voiceprint_config = None
+    _mqtt_server_config = None
+    _protocol_config = None
@@ -5,7 +5,7 @@ from config.config_loader import load_config
 from config.settings import check_config_file
 from datetime import datetime

-SERVER_VERSION = "0.8.8"
+SERVER_VERSION = "0.8.10"
 _logger_initialized = False


@@ -1,5 +1,4 @@
 import os
-import time
 import base64
 from typing import Optional, Dict

@@ -20,7 +19,7 @@ class DeviceBindException(Exception):

 class ManageApiClient:
    _instance = None
-    _client = None
+    _async_clients = {}  # 为每个事件循环存储独立的客户端
    _secret = None

    def __new__(cls, config):
@@ -32,7 +31,7 @@ class ManageApiClient:

    @classmethod
    def _init_client(cls, config):
-        """初始化持久化连接池"""
+        """初始化配置（延迟创建客户端）"""
        cls.config = config.get("manager-api")

        if not cls.config:
@@ -47,23 +46,41 @@ class ManageApiClient:
        cls._secret = cls.config.get("secret")
        cls.max_retries = cls.config.get("max_retries", 6)  # 最大重试次数
        cls.retry_delay = cls.config.get("retry_delay", 10)  # 初始重试延迟(秒)
-        # NOTE(goody): 2025/4/16 http相关资源统一管理，后续可以增加线程池或者超时
-        # 后续也可以统一配置apiToken之类的走通用的Auth
-        cls._client = httpx.Client(
-            base_url=cls.config.get("url"),
-            headers={
-                "User-Agent": f"PythonClient/2.0 (PID:{os.getpid()})",
-                "Accept": "application/json",
-                "Authorization": "Bearer " + cls._secret,
-            },
-            timeout=cls.config.get("timeout", 30),  # 默认超时时间30秒
-        )
+        # 不在这里创建 AsyncClient，延迟到实际使用时创建
+        cls._async_clients = {}

    @classmethod
-    def _request(cls, method: str, endpoint: str, **kwargs) -> Dict:
-        """发送单次HTTP请求并处理响应"""
+    async def _ensure_async_client(cls):
+        """确保异步客户端已创建（为每个事件循环创建独立的客户端）"""
+        import asyncio
+
+        try:
+            loop = asyncio.get_running_loop()
+            loop_id = id(loop)
+
+            # 为每个事件循环创建独立的客户端
+            if loop_id not in cls._async_clients:
+                cls._async_clients[loop_id] = httpx.AsyncClient(
+                    base_url=cls.config.get("url"),
+                    headers={
+                        "User-Agent": f"PythonClient/2.0 (PID:{os.getpid()})",
+                        "Accept": "application/json",
+                        "Authorization": "Bearer " + cls._secret,
+                    },
+                    timeout=cls.config.get("timeout", 30),
+                )
+            return cls._async_clients[loop_id]
+        except RuntimeError:
+            # 如果没有运行中的事件循环，创建一个临时的
+            raise Exception("必须在异步上下文中调用")
+
+    @classmethod
+    async def _async_request(cls, method: str, endpoint: str, **kwargs) -> Dict:
+        """发送单次异步HTTP请求并处理响应"""
+        # 确保客户端已创建
+        client = await cls._ensure_async_client()
        endpoint = endpoint.lstrip("/")
-        response = cls._client.request(method, endpoint, **kwargs)
+        response = await client.request(method, endpoint, **kwargs)
        response.raise_for_status()

        result = response.json()
@@ -96,22 +113,24 @@ class ManageApiClient:
        return False

    @classmethod
-    def _execute_request(cls, method: str, endpoint: str, **kwargs) -> Dict:
-        """带重试机制的请求执行器"""
+    async def _execute_async_request(cls, method: str, endpoint: str, **kwargs) -> Dict:
+        """带重试机制的异步请求执行器"""
+        import asyncio
+
        retry_count = 0

        while retry_count <= cls.max_retries:
            try:
-                # 执行请求
-                return cls._request(method, endpoint, **kwargs)
+                # 执行异步请求
+                return await cls._async_request(method, endpoint, **kwargs)
            except Exception as e:
                # 判断是否应该重试
                if retry_count < cls.max_retries and cls._should_retry(e):
                    retry_count += 1
                    print(
-                        f"{method} {endpoint} 请求失败，将在 {cls.retry_delay:.1f} 秒后进行第 {retry_count} 次重试"
+                        f"{method} {endpoint} 异步请求失败，将在 {cls.retry_delay:.1f} 秒后进行第 {retry_count} 次重试"
                    )
-                    time.sleep(cls.retry_delay)
+                    await asyncio.sleep(cls.retry_delay)
                    continue
                else:
                    # 不重试，直接抛出异常
@@ -119,22 +138,30 @@ class ManageApiClient:

    @classmethod
    def safe_close(cls):
-        """安全关闭连接池"""
-        if cls._client:
-            cls._client.close()
-            cls._instance = None
+        """安全关闭所有异步连接池"""
+        import asyncio
+
+        for client in list(cls._async_clients.values()):
+            try:
+                asyncio.run(client.aclose())
+            except Exception:
+                pass
+        cls._async_clients.clear()
+        cls._instance = None


-def get_server_config() -> Optional[Dict]:
+async def get_server_config() -> Optional[Dict]:
    """获取服务器基础配置"""
-    return ManageApiClient._instance._execute_request("POST", "/config/server-base")
+    return await ManageApiClient._instance._execute_async_request(
+        "POST", "/config/server-base"
+    )


-def get_agent_models(
+async def get_agent_models(
    mac_address: str, client_id: str, selected_module: Dict
 ) -> Optional[Dict]:
    """获取代理模型配置"""
-    return ManageApiClient._instance._execute_request(
+    return await ManageApiClient._instance._execute_async_request(
        "POST",
        "/config/agent-models",
        json={
@@ -145,28 +172,26 @@ def get_agent_models(
    )


-def save_mem_local_short(mac_address: str, short_momery: str) -> Optional[Dict]:
+async def generate_and_save_chat_summary(session_id: str) -> Optional[Dict]:
+    """生成并保存聊天记录总结"""
    try:
-        return ManageApiClient._instance._execute_request(
-            "PUT",
-            f"/agent/saveMemory/" + mac_address,
-            json={
-                "summaryMemory": short_momery,
-            },
+        return await ManageApiClient._instance._execute_async_request(
+            "POST",
+            f"/agent/chat-summary/{session_id}/save",
        )
    except Exception as e:
-        print(f"存储短期记忆到服务器失败: {e}")
+        print(f"生成并保存聊天记录总结失败: {e}")
        return None


-def report(
+async def report(
    mac_address: str, session_id: str, chat_type: int, content: str, audio, report_time
 ) -> Optional[Dict]:
-    """带熔断的业务方法示例"""
+    """异步聊天记录上报"""
    if not content or not ManageApiClient._instance:
        return None
    try:
-        return ManageApiClient._instance._execute_request(
+        return await ManageApiClient._instance._execute_async_request(
            "POST",
            f"/agent/chat-history/report",
            json={
@@ -0,0 +1,54 @@
+# MQTT协议配置示例
+# 将此配置添加到你的主配置文件中
+
+# 协议配置
+protocols:
+  enabled_protocols: ["websocket", "mqtt"]  # 启用的协议列表
+  websocket_enabled: true                   # WebSocket协议开关
+  mqtt_enabled: true                        # MQTT协议开关
+
+# MQTT服务器配置
+mqtt_server:
+  enabled: true                    # 是否启用MQTT服务器
+  host: "0.0.0.0"                 # 监听地址
+  port: 1883                      # MQTT端口
+  udp_port: 1883                  # UDP端口（用于音频传输）
+  public_ip: "your.server.ip"     # 公网IP地址
+  max_connections: 1000           # 最大连接数
+  heartbeat_interval: 30          # 心跳检查间隔（秒）
+  max_payload_size: 8192          # 最大消息载荷大小
+
+# 服务器配置（扩展）
+server:
+  ip: "0.0.0.0"
+  port: 8080                      # WebSocket端口
+  http_port: 8081
+  auth_key: ""
+  vision_explain: ""
+  
+  # MQTT服务器配置（嵌套）
+  mqtt_server:
+    enabled: true
+    host: "0.0.0.0"
+    port: 1883
+    udp_port: 1883
+    public_ip: "localhost"
+    max_connections: 1000
+    heartbeat_interval: 30
+    max_payload_size: 8192
+
+# 使用示例：
+# 1. 启动多协议服务器：
+#    python main_multi_protocol.py
+#
+# 2. WebSocket客户端连接：
+#    ws://your.server.ip:8080/
+#
+# 3. MQTT客户端连接：
+#    mqtt://your.server.ip:1883
+#    客户端ID格式：GID_test@@@mac_address@@@uuid
+#    或：GID_test@@@mac_address
+#
+# 4. UDP音频传输：
+#    客户端通过MQTT接收UDP配置后，使用UDP发送音频数据
+
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				INSERT INTO `sys_params` (id, param_code, param_value, value_type, param_type, remark) VALUES (311, 'enable_websocket_ping', 'false', 'boolean', 1, '是否启用WebSocket心跳保活机制');