diff --git a/README.md b/README.md
index 49bd28b..54ba4b5 100644
--- a/README.md
+++ b/README.md
@@ -1,49 +1,44 @@
-# AI 对话系统
+# AI 对话系统 v2.0
 
 支持网页端和Matrix端实时同步对话的AI聊天系统。
 
-## 功能特性
+## v2.0.0 新功能
 
-- **网页端对话**: 通过浏览器与AI进行对话
-- **Matrix端对话**: 配置Matrix Bot，用户可通过Matrix与AI对话
-- **实时同步**: 同一用户在网页端和Matrix端的对话自动同步
-- **后台管理**: 用户管理、对话记录、系统配置
+### 🎯 核心架构重构
 
-## 系统架构
+- **大模型池管理**：支持配置多个LLM Provider，Agent可选择使用哪个
+- **Agent管理**：每个Agent可独立配置系统设定、思考功能开关
+- **渠道独立绑定**：网页端和Matrix可绑定不同的Agent，或同一个Agent
+- **思考功能**：支持原生思考模型，兼容无思考功能的大模型
+
+### 📊 系统架构
 
 ```
-┌─────────────────────────────────────────────────────────┐
-│                    AI 对话系统                          │
-├─────────────────────────────────────────────────────────┤
-│  网页端 (用户A)  ←──┐                     ┌──→ Matrix端 │
-│                    │    同一会话同步      │   (用户A)   │
-├─────────────────────────────────────────────────────────┤
-│  后端服务 (FastAPI + WebSocket)                         │
-│  - 会话管理                                             │
-│  - 消息存储                                             │
-│  - Matrix Bot 集成                                      │
-│  - AI 模型调用                                          │
-├─────────────────────────────────────────────────────────┤
-│  后台管理                                               │
-│  - 用户管理                                             │
-│  - 对话记录                                             │
-│  - 系统配置                                             │
-└─────────────────────────────────────────────────────────┘
+┌─────────────────────────────────────────────────────────────────────┐
+│                        大模型池 (LLMProvider)                        │
+│  多个LLM API配置，支持思考功能检测                                     │
+└─────────────────────────────────────────────────────────────────────┘
+                              ↓ 被选择
+┌─────────────────────────────────────────────────────────────────────┐
+│                           Agent                                      │
+│  系统设定、思考开关、思考提示词、大模型选择                              │
+└─────────────────────────────────────────────────────────────────────┘
+                              ↓ 映射绑定
+┌─────────────────────────────────────────────────────────────────────┐
+│                      渠道 (Channel)                                  │
+│  网页端、Matrix端各自独立配置                                          │
+└─────────────────────────────────────────────────────────────────────┘
 ```
 
 ## 端口分配
 
-- 19020: 主服务（网页端 + API）
-- 后台管理: http://localhost:19020/admin
+- 19020: 主服务（网页端 + API + Matrix Bot）
 
 ## 快速启动
 
 ```bash
-# 安装依赖
-pip3 install -r requirements.txt
-
-# 启动服务
-./start.sh
+# v2.0 启动
+./start_v2.sh
 
 # 检查状态
 ./status.sh
@@ -52,43 +47,105 @@ pip3 install -r requirements.txt
 ./stop.sh
 ```
 
-## 配置Matrix Bot
+## 后台管理
 
-在后台管理页面配置以下参数：
+访问 http://localhost:19020/admin
 
-| 配置项 | 说明 |
-|--------|------|
-| matrix_homeserver | Matrix服务器地址，如 https://matrix.tphai.com |
-| matrix_username | Matrix Bot用户名，如 @ai-bot:matrix.org |
-| matrix_password | Matrix Bot密码 |
+### 管理功能
 
-配置完成后，其他Matrix用户可以直接与Bot对话。
+1. **大模型池管理**
+   - 添加/编辑/删除LLM Provider
+   - 测试API连接
+   - 获取可用模型列表
+   - 配置思考功能支持
+
+2. **Agent管理**
+   - 创建多个Agent
+   - 配置系统设定（System Prompt）
+   - 开关思考功能
+   - 选择大模型池
+
+3. **渠道管理**
+   - 网页端/Matrix独立配置
+   - 绑定Agent（支持优先级/条件）
+   - Matrix Bot配置
 
 ## API接口
 
-### 会话管理
+### v2 新增API
 
-- `GET /api/conversations` - 获取会话列表
-- `POST /api/conversations` - 创建新会话
-- `GET /api/conversations/{id}/messages` - 获取会话消息
-- `DELETE /api/conversations/{id}` - 删除会话
+```
+# 大模型池
+GET    /api/v2/providers           # 获取所有Provider
+POST   /api/v2/providers           # 创建Provider
+PUT    /api/v2/providers/{id}      # 更新Provider
+DELETE /api/v2/providers/{id}      # 删除Provider
+POST   /api/v2/providers/models    # 获取API模型列表
+POST   /api/v2/providers/test      # 测试API连接
 
-### 后台管理
+# Agent
+GET    /api/v2/agents              # 获取所有Agent
+POST   /api/v2/agents              # 创建Agent
+PUT    /api/v2/agents/{id}         # 更新Agent
+DELETE /api/v2/agents/{id}         # 删除Agent
+POST   /api/v2/agents/{id}/default # 设为默认Agent
+GET    /api/v2/agents/{id}/config  # 获取Agent完整配置
 
-- `GET /api/admin/stats` - 获取统计数据
-- `GET /api/admin/users` - 获取用户列表
-- `GET /api/admin/conversations` - 获取对话列表
-- `GET /api/admin/config` - 获取系统配置
-- `POST /api/admin/config` - 更新系统配置
+# 渠道
+GET    /api/v2/channels            # 获取所有渠道
+POST   /api/v2/channels            # 创建渠道
+PUT    /api/v2/channels/{id}       # 更新渠道
+PUT    /api/v2/channels/{id}/config # 更新渠道配置
+POST   /api/v2/channels/bind       # 绑定Agent
+DELETE /api/v2/channels/unbind/{id} # 解绑Agent
+```
+
+### 原有API（兼容）
+
+```
+GET    /api/conversations          # 获取会话列表
+GET    /api/conversations/latest   # 获取最新会话
+POST   /api/conversations          # 创建新会话
+GET    /api/conversations/{id}/messages # 获取消息
+DELETE /api/conversations/{id}     # 删除会话
+GET    /api/admin/stats            # 统计数据
+```
+
+## 思考功能
+
+### 配置方式
+
+1. **原生支持**：某些模型原生支持思考（如DeepSeek R1）
+   - Provider配置 `supports_thinking: true`
+   - 可配置专门的 `thinking_model`
+
+2. **兼容模式**：不支持原生思考的模型
+   - Agent配置 `thinking_prompt` 思考提示词
+   - 配置 `thinking_prefix`/`thinking_suffix` 识别思考内容
+   - 系统会将思考提示添加到System Prompt
+
+### Matrix命令
+
+```
+/new              # 创建新会话
+/agent <name>     # 切换Agent
+/thinking on      # 开启思考功能
+/thinking off     # 关闭思考功能
+```
 
 ## 技术栈
 
 - **后端**: FastAPI + WebSocket
-- **数据库**: SQLite (SQLAlchemy)
-- **Matrix**: matrix-nio
-- **前端**: HTML + JavaScript (原生)
-- **AI**: 可配置任意LLM API（默认使用本地LLM Proxy）
+- **数据库**: SQLite (SQLAlchemy) + 新增v2模型
+- **Matrix**: matrix-nio (支持加密)
+- **前端**: Bootstrap 5 + 原生JavaScript
+- **AI**: 可配置多个LLM API
 
 ## 仓库地址
 
-http://192.168.2.8:12007/coder/ai-chat-system
\ No newline at end of file
+http://192.168.2.8:12007/coder/ai-chat-system
+
+## 版本历史
+
+- v2.0.0 (2026-04-12): 架构重构，大模型池、Agent管理、渠道独立绑定、思考功能
+- v1.0.0: 基础版本，网页端+Matrix同步对话
\ No newline at end of file
diff --git a/main_v2.py b/main_v2.py
new file mode 100644
index 0000000..c21e5f4
--- /dev/null
+++ b/main_v2.py
@@ -0,0 +1,805 @@
+"""
+AI对话系统 v2.0.0 - 主应用
+支持：大模型池、Agent管理、渠道独立绑定、思考功能开关
+"""
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Depends, HTTPException, Request
+from fastapi.responses import HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from sqlalchemy.orm import Session
+from typing import Dict, Set, Optional
+import asyncio
+import json
+import logging
+from datetime import datetime
+import os
+
+# 使用新的数据模型
+from models_v2 import (
+    init_db, get_db, SessionLocal, 
+    User, Conversation, Message, SystemConfig,
+    LLMProvider, Agent, Channel, ChannelAgentMapping, MatrixRoomMapping,
+    init_default_data
+)
+from services.llm_service import llm_service
+from services.agent_service import AgentService, LLMProviderService, ChannelService
+from services.conversation_service import ConversationService
+
+# 配置日志
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# 创建应用
+app = FastAPI(title="AI对话系统 v2.0", version="2.0.0")
+
+# 静态文件和模板
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+app.mount("/static", StaticFiles(directory=os.path.join(BASE_DIR, "static")), name="static")
+templates = Jinja2Templates(directory=os.path.join(BASE_DIR, "templates"))
+
+# WebSocket连接管理
+class ConnectionManager:
+    def __init__(self):
+        self.active_connections: Dict[str, Set[WebSocket]] = {}
+    
+    async def connect(self, websocket: WebSocket, user_id: str):
+        await websocket.accept()
+        if user_id not in self.active_connections:
+            self.active_connections[user_id] = set()
+        self.active_connections[user_id].add(websocket)
+        logger.info(f"WebSocket连接: {user_id}")
+    
+    def disconnect(self, websocket: WebSocket, user_id: str):
+        if user_id in self.active_connections:
+            self.active_connections[user_id].discard(websocket)
+            if not self.active_connections[user_id]:
+                del self.active_connections[user_id]
+    
+    async def send_to_user(self, user_id: str, message: dict):
+        if user_id in self.active_connections:
+            for connection in self.active_connections[user_id]:
+                try:
+                    await connection.send_json(message)
+                except:
+                    pass
+
+
+manager = ConnectionManager()
+
+# 固定主用户ID
+MAIN_USER_ID = "main_user"
+
+
+# ==================== 页面路由 ====================
+
+@app.get("/", response_class=HTMLResponse)
+async def index(request: Request):
+    """主页 - 聊天界面"""
+    return templates.TemplateResponse("index.html", {"request": request})
+
+
+@app.get("/admin", response_class=HTMLResponse)
+async def admin(request: Request):
+    """后台管理 - v2.0版本"""
+    return templates.TemplateResponse("admin_v2/index.html", {"request": request})
+
+
+# ==================== v2 API路由 ====================
+
+# ===== 大模型池 API =====
+
+@app.get("/api/v2/providers")
+async def get_providers(db: Session = Depends(get_db)):
+    """获取所有大模型池"""
+    service = LLMProviderService(db)
+    providers = service.get_all_providers()
+    
+    return {
+        "providers": [
+            {
+                "id": p.id,
+                "name": p.name,
+                "api_base": p.api_base,
+                "api_key": p.api_key,
+                "models": p.models,
+                "default_model": p.default_model,
+                "supports_thinking": p.supports_thinking,
+                "thinking_model": p.thinking_model,
+                "max_tokens": p.max_tokens,
+                "temperature": p.temperature,
+                "is_active": p.is_active,
+                "priority": p.priority,
+                "description": p.description
+            }
+            for p in providers
+        ]
+    }
+
+
+@app.post("/api/v2/providers")
+async def create_provider(data: dict, db: Session = Depends(get_db)):
+    """创建大模型池"""
+    service = LLMProviderService(db)
+    
+    # 检查名称是否已存在
+    if service.get_provider_by_name(data.get('name')):
+        return {"success": False, "message": "名称已存在"}
+    
+    provider = service.create_provider(data)
+    return {"success": True, "provider": {"id": provider.id, "name": provider.name}}
+
+
+@app.put("/api/v2/providers/{provider_id}")
+async def update_provider(provider_id: int, data: dict, db: Session = Depends(get_db)):
+    """更新大模型池"""
+    service = LLMProviderService(db)
+    provider = service.update_provider(provider_id, data)
+    
+    if not provider:
+        return {"success": False, "message": "Provider不存在"}
+    
+    return {"success": True, "provider": {"id": provider.id, "name": provider.name}}
+
+
+@app.delete("/api/v2/providers/{provider_id}")
+async def delete_provider(provider_id: int, db: Session = Depends(get_db)):
+    """删除大模型池"""
+    service = LLMProviderService(db)
+    success = service.delete_provider(provider_id)
+    
+    if not success:
+        return {"success": False, "message": "无法删除（可能有Agent在使用）"}
+    
+    return {"success": True}
+
+
+@app.post("/api/v2/providers/models")
+async def fetch_models(data: dict):
+    """从API获取模型列表"""
+    api_base = data.get('api_base')
+    api_key = data.get('api_key', '')
+    
+    models = await llm_service.get_available_models(api_base, api_key)
+    return {"models": models}
+
+
+@app.post("/api/v2/providers/test")
+async def test_provider(data: dict):
+    """测试大模型连接"""
+    api_base = data.get('api_base')
+    api_key = data.get('api_key', '')
+    model = data.get('model', 'auto')
+    
+    result = await llm_service.test_connection(api_base, api_key, model)
+    return result
+
+
+# ===== Agent API =====
+
+@app.get("/api/v2/agents")
+async def get_agents(db: Session = Depends(get_db)):
+    """获取所有Agent"""
+    service = AgentService(db)
+    agents = service.get_all_agents()
+    
+    # 获取Provider名称
+    providers = {p.id: p.name for p in db.query(LLMProvider).all()}
+    
+    return {
+        "agents": [
+            {
+                "id": a.id,
+                "name": a.name,
+                "display_name": a.display_name,
+                "llm_provider_id": a.llm_provider_id,
+                "llm_provider_name": providers.get(a.llm_provider_id),
+                "model_override": a.model_override,
+                "system_prompt": a.system_prompt,
+                "enable_thinking": a.enable_thinking,
+                "thinking_prompt": a.thinking_prompt,
+                "thinking_prefix": a.thinking_prefix,
+                "thinking_suffix": a.thinking_suffix,
+                "max_history": a.max_history,
+                "temperature_override": a.temperature_override,
+                "is_default": a.is_default,
+                "is_active": a.is_active,
+                "description": a.description
+            }
+            for a in agents
+        ]
+    }
+
+
+@app.post("/api/v2/agents")
+async def create_agent(data: dict, db: Session = Depends(get_db)):
+    """创建Agent"""
+    service = AgentService(db)
+    
+    # 检查名称是否已存在
+    if service.get_agent_by_name(data.get('name')):
+        return {"success": False, "message": "Agent名称已存在"}
+    
+    # 检查Provider是否存在
+    provider_service = LLMProviderService(db)
+    if not provider_service.get_provider(data.get('llm_provider_id')):
+        return {"success": False, "message": "选择的LLM Provider不存在"}
+    
+    agent = service.create_agent(data)
+    
+    # 如果设为默认，更新其他
+    if data.get('is_default'):
+        service.set_default_agent(agent.id)
+    
+    return {"success": True, "agent": {"id": agent.id, "name": agent.name}}
+
+
+@app.put("/api/v2/agents/{agent_id}")
+async def update_agent(agent_id: int, data: dict, db: Session = Depends(get_db)):
+    """更新Agent"""
+    service = AgentService(db)
+    
+    # 如果设为默认，先更新
+    if data.get('is_default'):
+        service.set_default_agent(agent_id)
+    
+    agent = service.update_agent(agent_id, data)
+    
+    if not agent:
+        return {"success": False, "message": "Agent不存在"}
+    
+    return {"success": True, "agent": {"id": agent.id, "name": agent.name}}
+
+
+@app.delete("/api/v2/agents/{agent_id}")
+async def delete_agent(agent_id: int, db: Session = Depends(get_db)):
+    """删除Agent"""
+    service = AgentService(db)
+    success = service.delete_agent(agent_id)
+    
+    if not success:
+        return {"success": False, "message": "无法删除默认Agent"}
+    
+    return {"success": True}
+
+
+@app.post("/api/v2/agents/{agent_id}/default")
+async def set_agent_default(agent_id: int, db: Session = Depends(get_db)):
+    """设置默认Agent"""
+    service = AgentService(db)
+    success = service.set_default_agent(agent_id)
+    
+    return {"success": success}
+
+
+@app.get("/api/v2/agents/{agent_id}/config")
+async def get_agent_config(agent_id: int, db: Session = Depends(get_db)):
+    """获取Agent完整配置（含LLM Provider）"""
+    service = AgentService(db)
+    config = service.get_agent_config(agent_id)
+    
+    return {"config": config}
+
+
+# ===== 渠道 API =====
+
+@app.get("/api/v2/channels")
+async def get_channels(db: Session = Depends(get_db)):
+    """获取所有渠道及绑定关系"""
+    service = ChannelService(db)
+    channels = service.get_all_channels()
+    
+    # 获取所有绑定关系
+    mappings = db.query(ChannelAgentMapping).order_by(ChannelAgentMapping.priority).all()
+    
+    agents = {a.id: a for a in db.query(Agent).all()}
+    
+    return {
+        "channels": [
+            {
+                "id": c.id,
+                "channel_type": c.channel_type,
+                "name": c.name,
+                "config": c.config,
+                "is_active": c.is_active,
+                "is_primary": c.is_primary,
+                "agent_mappings": [
+                    {
+                        "id": m.id,
+                        "agent": {
+                            "id": agents[m.agent_id].id if m.agent_id in agents else None,
+                            "name": agents[m.agent_id].name if m.agent_id in agents else None,
+                            "display_name": agents[m.agent_id].display_name if m.agent_id in agents else None,
+                            "is_active": agents[m.agent_id].is_active if m.agent_id in agents else None
+                        },
+                        "priority": m.priority,
+                        "mode": m.mode,
+                        "conditions": m.conditions
+                    }
+                    for m in mappings if m.channel_id == c.id
+                ]
+            }
+            for c in channels
+        ],
+        "mappings": [
+            {
+                "id": m.id,
+                "channel_id": m.channel_id,
+                "channel_type": channels[0].channel_type if channels else None,  # 需要从Channel获取
+                "channel_name": next((c.name for c in channels if c.id == m.channel_id), ""),
+                "agent_id": m.agent_id,
+                "agent_name": agents[m.agent_id].display_name if m.agent_id in agents else "",
+                "priority": m.priority,
+                "mode": m.mode,
+                "conditions": m.conditions
+            }
+            for m in mappings
+        ]
+    }
+
+
+@app.post("/api/v2/channels")
+async def create_channel(data: dict, db: Session = Depends(get_db)):
+    """创建渠道"""
+    service = ChannelService(db)
+    channel = service.create_channel(data)
+    
+    return {"success": True, "channel": {"id": channel.id, "name": channel.name}}
+
+
+@app.put("/api/v2/channels/{channel_id}")
+async def update_channel(channel_id: int, data: dict, db: Session = Depends(get_db)):
+    """更新渠道"""
+    service = ChannelService(db)
+    channel = service.update_channel(channel_id, data)
+    
+    if not channel:
+        return {"success": False, "message": "渠道不存在"}
+    
+    return {"success": True}
+
+
+@app.put("/api/v2/channels/{channel_id}/config")
+async def update_channel_config(channel_id: int, data: dict, db: Session = Depends(get_db)):
+    """更新渠道配置（如Matrix配置）"""
+    channel = db.query(Channel).filter(Channel.id == channel_id).first()
+    
+    if not channel:
+        return {"success": False, "message": "渠道不存在"}
+    
+    channel.config = data.get('config', {})
+    db.commit()
+    
+    # 如果是Matrix渠道，重新初始化Matrix Bot
+    if channel.channel_type == 'matrix':
+        # TODO: 重启Matrix Bot
+        pass
+    
+    return {"success": True}
+
+
+@app.post("/api/v2/channels/bind")
+async def bind_agent_to_channel(data: dict, db: Session = Depends(get_db)):
+    """绑定Agent到渠道"""
+    service = ChannelService(db)
+    
+    channel_id = data.get('channel_id')
+    agent_id = data.get('agent_id')
+    
+    # 检查渠道和Agent是否存在
+    if not service.get_channel(channel_id):
+        return {"success": False, "message": "渠道不存在"}
+    
+    agent_service = AgentService(db)
+    if not agent_service.get_agent(agent_id):
+        return {"success": False, "message": "Agent不存在"}
+    
+    mapping = service.bind_agent(
+        channel_id=channel_id,
+        agent_id=agent_id,
+        priority=data.get('priority', 0),
+        mode=data.get('mode', 'single'),
+        conditions=data.get('conditions')
+    )
+    
+    return {"success": True, "mapping": {"id": mapping.id}}
+
+
+@app.delete("/api/v2/channels/unbind/{mapping_id}")
+async def unbind_agent(mapping_id: int, db: Session = Depends(get_db)):
+    """解绑Agent"""
+    service = ChannelService(db)
+    success = service.unbind_agent(mapping_id)
+    
+    return {"success": success}
+
+
+# ==================== 对话 API（保留原有） ====================
+
+@app.get("/api/conversations")
+async def get_conversations(db: Session = Depends(get_db)):
+    """获取会话列表"""
+    conv_service = ConversationService(db)
+    user = conv_service.get_or_create_user(MAIN_USER_ID, display_name="主用户", user_type='web')
+    conversations = conv_service.get_user_conversations(user.id)
+    
+    return {
+        "conversations": [
+            {
+                "id": c.conversation_id,
+                "title": c.title or "新对话",
+                "created_at": c.created_at.isoformat(),
+                "updated_at": c.updated_at.isoformat()
+            }
+            for c in conversations
+        ]
+    }
+
+
+@app.get("/api/conversations/latest")
+async def get_latest_conversation(db: Session = Depends(get_db)):
+    """获取最新会话"""
+    conv_service = ConversationService(db)
+    user = conv_service.get_or_create_user(MAIN_USER_ID, display_name="主用户", user_type='web')
+    conversations = conv_service.get_user_conversations(user.id)
+    
+    if conversations:
+        latest = conversations[0]
+        return {
+            "conversation": {
+                "id": latest.conversation_id,
+                "title": latest.title or "新对话",
+                "updated_at": latest.updated_at.isoformat()
+            }
+        }
+    return {"conversation": None}
+
+
+@app.post("/api/conversations")
+async def create_conversation(db: Session = Depends(get_db)):
+    """创建新会话"""
+    conv_service = ConversationService(db)
+    user = conv_service.get_or_create_user(MAIN_USER_ID, display_name="主用户", user_type='web')
+    conversation = conv_service.create_conversation(user.id)
+    
+    return {
+        "id": conversation.conversation_id,
+        "title": conversation.title or "新对话",
+        "created_at": conversation.created_at.isoformat()
+    }
+
+
+@app.get("/api/conversations/{conversation_id}/messages")
+async def get_messages(conversation_id: str, db: Session = Depends(get_db)):
+    """获取会话消息"""
+    conv_service = ConversationService(db)
+    conversation = conv_service.get_conversation(conversation_id)
+    
+    if not conversation:
+        raise HTTPException(status_code=404, detail="会话不存在")
+    
+    messages = conv_service.get_messages(conversation.id)
+    
+    return {
+        "messages": [
+            {
+                "id": m.id,
+                "role": m.role,
+                "content": m.content,
+                "thinking_content": m.thinking_content,  # v2新增
+                "source": m.source,
+                "agent_id": m.agent_id,  # v2新增
+                "model_used": m.model_used,  # v2新增
+                "created_at": m.created_at.isoformat()
+            }
+            for m in messages
+        ]
+    }
+
+
+@app.delete("/api/conversations/{conversation_id}")
+async def delete_conversation(conversation_id: str, db: Session = Depends(get_db)):
+    """删除会话"""
+    conv_service = ConversationService(db)
+    success = conv_service.delete_conversation(conversation_id)
+    
+    if not success:
+        raise HTTPException(status_code=404, detail="会话不存在")
+    
+    return {"success": True}
+
+
+# ==================== WebSocket路由 ====================
+
+@app.websocket("/ws/{user_id}")
+async def websocket_endpoint(websocket: WebSocket, user_id: str, db: Session = Depends(get_db)):
+    """WebSocket连接 - 实时对话"""
+    actual_user_id = MAIN_USER_ID
+    await manager.connect(websocket, actual_user_id)
+    conv_service = ConversationService(db)
+    user = conv_service.get_or_create_user(MAIN_USER_ID, display_name="主用户", user_type='web')
+    
+    # 获取默认Agent配置
+    agent_service = AgentService(db)
+    default_agent = agent_service.get_default_agent()
+    
+    current_conversation_id = None
+    current_agent_id = default_agent.id if default_agent else None
+    
+    try:
+        while True:
+            data = await websocket.receive_json()
+            action = data.get("action")
+            
+            if action == "select_conversation":
+                current_conversation_id = data.get("conversation_id")
+                conversation = conv_service.get_conversation(current_conversation_id)
+                
+                if conversation:
+                    messages = conv_service.get_messages(conversation.id)
+                    await websocket.send_json({
+                        "type": "history",
+                        "conversation_id": current_conversation_id,
+                        "messages": [
+                            {
+                                "role": m.role,
+                                "content": m.content,
+                                "thinking_content": m.thinking_content,
+                                "source": m.source,
+                                "created_at": m.created_at.isoformat()
+                            }
+                            for m in messages
+                        ]
+                    })
+            
+            elif action == "switch_agent":
+                # 切换Agent
+                new_agent_id = data.get("agent_id")
+                agent = agent_service.get_agent(new_agent_id)
+                if agent and agent.is_active:
+                    current_agent_id = new_agent_id
+                    await websocket.send_json({
+                        "type": "agent_switched",
+                        "agent_id": current_agent_id,
+                        "agent_name": agent.display_name or agent.name
+                    })
+            
+            elif action == "chat":
+                message = data.get("message", "")
+                conversation_id = data.get("conversation_id")
+                enable_thinking = data.get("enable_thinking", True)  # 可临时关闭思考
+                
+                if not message.strip():
+                    continue
+                
+                # 获取或创建会话
+                if conversation_id:
+                    conversation = conv_service.get_conversation(conversation_id)
+                else:
+                    conversation = conv_service.create_conversation(user.id)
+                    conversation_id = conversation.conversation_id
+                    await websocket.send_json({
+                        "type": "conversation_created",
+                        "conversation_id": conversation_id
+                    })
+                
+                # 保存用户消息
+                user_msg = conv_service.add_message(
+                    conversation_id=conversation.id,
+                    role='user',
+                    content=message,
+                    source='web'
+                )
+                
+                # 广播用户消息
+                await manager.send_to_user(MAIN_USER_ID, {
+                    "type": "user_message",
+                    "conversation_id": conversation_id,
+                    "message": {
+                        "id": user_msg.id,
+                        "role": "user",
+                        "content": message,
+                        "source": "web",
+                        "created_at": user_msg.created_at.isoformat()
+                    }
+                })
+                
+                # 获取Agent配置
+                agent_config = agent_service.get_agent_config(current_agent_id)
+                
+                if not agent_config or not agent_config.get('provider'):
+                    await websocket.send_json({
+                        "type": "error",
+                        "message": "Agent配置不完整"
+                    })
+                    continue
+                
+                # 获取对话历史
+                history = conv_service.get_conversation_history(conversation_id, limit=agent_config['agent'].get('max_history', 20))
+                
+                # 调用LLM
+                try:
+                    # 发送"正在思考"状态
+                    if agent_config['agent'].get('enable_thinking') and enable_thinking:
+                        await websocket.send_json({
+                            "type": "thinking_start",
+                            "conversation_id": conversation_id
+                        })
+                    
+                    response, thinking_content = await llm_service.chat(
+                        messages=history,
+                        provider_config=agent_config['provider'],
+                        agent_config=agent_config['agent'],
+                        enable_thinking=enable_thinking
+                    )
+                    
+                    # 发送思考内容
+                    if thinking_content:
+                        await websocket.send_json({
+                            "type": "thinking_content",
+                            "conversation_id": conversation_id,
+                            "content": thinking_content
+                        })
+                    
+                    # 发送思考结束
+                    await websocket.send_json({
+                        "type": "thinking_end",
+                        "conversation_id": conversation_id
+                    })
+                    
+                    # 保存AI回复
+                    assistant_msg = conv_service.add_message(
+                        conversation_id=conversation.id,
+                        role='assistant',
+                        content=response,
+                        source='web',
+                        thinking_content=thinking_content,
+                        agent_id=current_agent_id,
+                        model_used=agent_config['provider'].get('default_model')
+                    )
+                    
+                    # 广播AI回复
+                    await manager.send_to_user(MAIN_USER_ID, {
+                        "type": "assistant_message",
+                        "conversation_id": conversation_id,
+                        "message": {
+                            "id": assistant_msg.id,
+                            "role": "assistant",
+                            "content": response,
+                            "thinking_content": thinking_content,
+                            "source": "web",
+                            "agent_id": current_agent_id,
+                            "agent_name": agent_config['agent'].get('display_name'),
+                            "created_at": assistant_msg.created_at.isoformat()
+                        }
+                    })
+                    
+                except Exception as e:
+                    logger.error(f"LLM调用失败: {e}")
+                    await websocket.send_json({
+                        "type": "error",
+                        "message": f"AI服务暂时不可用: {str(e)}"
+                    })
+    
+    except WebSocketDisconnect:
+        manager.disconnect(websocket, user_id)
+    except Exception as e:
+        logger.error(f"WebSocket错误: {e}")
+        manager.disconnect(websocket, user_id)
+
+
+# ==================== 后台管理API ====================
+
+@app.get("/api/admin/stats")
+async def get_stats(db: Session = Depends(get_db)):
+    """获取统计数据"""
+    total_users = db.query(User).count()
+    total_conversations = db.query(Conversation).count()
+    total_messages = db.query(Message).count()
+    
+    return {
+        "total_users": total_users,
+        "total_conversations": total_conversations,
+        "total_messages": total_messages
+    }
+
+
+# ==================== Matrix消息处理回调 ====================
+
+async def handle_matrix_message(
+    action: str, 
+    conversation_id: str = None, 
+    user_message: str = None, 
+    room_id: str = None, 
+    message_id: int = None, 
+    sender: str = None,
+    content: str = None,
+    thinking_content: str = None,
+    agent_id: int = None,
+    agent_name: str = None
+):
+    """处理从Matrix收到的消息"""
+    
+    if action == "new_conversation":
+        await manager.send_to_user(MAIN_USER_ID, {
+            "type": "new_conversation",
+            "conversation_id": conversation_id
+        })
+        return
+    
+    if action == "user_message":
+        await manager.send_to_user(MAIN_USER_ID, {
+            "type": "user_message",
+            "conversation_id": conversation_id,
+            "message": {
+                "id": message_id,
+                "role": "user",
+                "content": user_message,
+                "source": "matrix",
+                "sender": sender,
+                "created_at": datetime.now().isoformat()
+            }
+        })
+        return
+    
+    if action == "assistant_message":
+        await manager.send_to_user(MAIN_USER_ID, {
+            "type": "assistant_message",
+            "conversation_id": conversation_id,
+            "message": {
+                "id": message_id,
+                "role": "assistant",
+                "content": content,
+                "thinking_content": thinking_content,
+                "source": "matrix",
+                "agent_id": agent_id,
+                "agent_name": agent_name,
+                "created_at": datetime.now().isoformat()
+            }
+        })
+        return
+
+
+# ==================== 启动和关闭 ====================
+
+# 导入Matrix Bot
+try:
+    from services.matrix_service_v2 import matrix_bot
+    MATRIX_V2 = True
+except ImportError:
+    from services.matrix_service import matrix_bot
+    MATRIX_V2 = False
+
+@app.on_event("startup")
+async def startup():
+    """应用启动"""
+    init_db()
+    logger.info("数据库初始化完成")
+    
+    # 初始化默认数据
+    init_default_data()
+    
+    # 初始化Matrix Bot
+    try:
+        success = await matrix_bot.init_from_config()
+        if success and matrix_bot.is_running:
+            asyncio.create_task(matrix_bot.start_sync(handle_matrix_message))
+            logger.info("Matrix Bot v2 已启动")
+        else:
+            logger.info("Matrix Bot 未配置或未启用")
+    except Exception as e:
+        logger.warning(f"Matrix Bot初始化失败: {e}")
+
+
+@app.on_event("shutdown")
+async def shutdown():
+    """应用关闭"""
+    try:
+        await matrix_bot.disconnect()
+    except:
+        pass
+    logger.info("应用已关闭")
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=19020)
\ No newline at end of file
diff --git a/models_v2.py b/models_v2.py
new file mode 100644
index 0000000..3d29dfd
--- /dev/null
+++ b/models_v2.py
@@ -0,0 +1,342 @@
+"""
+AI对话系统 v2.0.0 - 数据库模型重构
+支持：大模型池、Agent管理、渠道独立绑定、思考功能开关
+"""
+from sqlalchemy import create_engine, Column, Integer, String, Text, Boolean, DateTime, ForeignKey, JSON, Float
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker, relationship
+from datetime import datetime
+import os
+
+DATABASE_URL = os.environ.get('DATABASE_URL', 'sqlite:///./ai_chat_v2.db')
+
+engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+
+# ==================== 大模型池 ====================
+
+class LLMProvider(Base):
+    """大模型提供商/池配置"""
+    __tablename__ = 'llm_providers'
+    
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String(100), unique=True, index=True)  # 名称标识，如 "DeepSeek", "本地LLM"
+    api_base = Column(String(500))  # API地址
+    api_key = Column(String(500))  # API密钥
+    models = Column(JSON, default=list)  # 可用模型列表 [{"id": "xxx", "name": "xxx"}]
+    default_model = Column(String(100))  # 默认模型
+    
+    # 思考功能支持
+    supports_thinking = Column(Boolean, default=False)  # 是否原生支持思考
+    thinking_model = Column(String(100), nullable=True)  # 思考模式模型名（如有单独模型）
+    
+    # 配额和限制
+    max_tokens = Column(Integer, default=4096)
+    temperature = Column(Float, default=0.7)
+    
+    # 状态
+    is_active = Column(Boolean, default=True)
+    priority = Column(Integer, default=0)  # 优先级，用于自动选择
+    description = Column(Text, nullable=True)
+    
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    
+    # 关联
+    agents = relationship("Agent", back_populates="llm_provider")
+
+
+# ==================== Agent ====================
+
+class Agent(Base):
+    """智能体配置"""
+    __tablename__ = 'agents'
+    
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String(100), unique=True, index=True)  # Agent名称
+    display_name = Column(String(100))  # 显示名称
+    
+    # 大模型配置
+    llm_provider_id = Column(Integer, ForeignKey('llm_providers.id'))
+    model_override = Column(String(100), nullable=True)  # 覆盖Provider默认模型
+    
+    # 系统设定
+    system_prompt = Column(Text, default="你是一个有用的AI助手。")  # 系统提示词
+    
+    # 思考功能
+    enable_thinking = Column(Boolean, default=True)  # 是否启用思考
+    thinking_prompt = Column(Text, nullable=True)  # 思考提示词模板
+    thinking_prefix = Column(String(50), default="<think>")  # 思考内容前缀标识
+    thinking_suffix = Column(String(50), default="</think>")  # 思考内容后缀标识
+    
+    # 其他配置
+    max_history = Column(Integer, default=20)  # 最大历史消息数
+    temperature_override = Column(Float, nullable=True)  # 覆盖温度
+    
+    # 状态
+    is_active = Column(Boolean, default=True)
+    is_default = Column(Boolean, default=False)  # 是否为默认Agent
+    description = Column(Text, nullable=True)
+    
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    
+    # 关联
+    llm_provider = relationship("LLMProvider", back_populates="agents")
+    channel_mappings = relationship("ChannelAgentMapping", back_populates="agent")
+
+
+# ==================== 渠道 ====================
+
+class Channel(Base):
+    """渠道配置 - 网页端、Matrix端等"""
+    __tablename__ = 'channels'
+    
+    id = Column(Integer, primary_key=True, index=True)
+    channel_type = Column(String(20), index=True)  # web, matrix, telegram, etc.
+    name = Column(String(100))  # 渠道名称，如 "网页端主入口", "Matrix AI Bot"
+    
+    # 渠道配置（JSON）
+    config = Column(JSON, default=dict)
+    # Matrix示例: {"homeserver": "xxx", "username": "xxx", "password": "xxx"}
+    # Web示例: {"require_login": false, "session_timeout": 3600}
+    
+    # 状态
+    is_active = Column(Boolean, default=True)
+    is_primary = Column(Boolean, default=False)  # 是否为主要渠道
+    
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    
+    # 关联
+    agent_mappings = relationship("ChannelAgentMapping", back_populates="channel", order_by="ChannelAgentMapping.priority")
+    conversations = relationship("Conversation", back_populates="channel")
+
+
+# ==================== 渠道-Agent映射 ====================
+
+class ChannelAgentMapping(Base):
+    """渠道与Agent的映射关系"""
+    __tablename__ = 'channel_agent_mappings'
+    
+    id = Column(Integer, primary_key=True, index=True)
+    channel_id = Column(Integer, ForeignKey('channels.id'))
+    agent_id = Column(Integer, ForeignKey('agents.id'))
+    
+    # 映射配置
+    priority = Column(Integer, default=0)  # 优先级（数字越小优先级越高）
+    mode = Column(String(20), default='single')  # single(单Agent), round_robin(轮询), fallback(备用)
+    weight = Column(Integer, default=1)  # 轮询权重
+    
+    # 条件配置（可选）
+    conditions = Column(JSON, nullable=True)  # 条件触发，如 {"user_type": "vip"}
+    
+    is_active = Column(Boolean, default=True)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    
+    # 关联
+    channel = relationship("Channel", back_populates="agent_mappings")
+    agent = relationship("Agent", back_populates="channel_mappings")
+
+
+# ==================== 用户和会话（保留原有结构，增加渠道关联） ====================
+
+class User(Base):
+    """用户表"""
+    __tablename__ = 'users'
+    
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(String(100), unique=True, index=True)
+    display_name = Column(String(100))
+    user_type = Column(String(20), default='web')  # web, matrix, telegram
+    matrix_user_id = Column(String(200), nullable=True)
+    
+    # 用户级别（用于Agent选择条件）
+    user_level = Column(String(20), default='normal')  # normal, vip, admin
+    
+    created_at = Column(DateTime, default=datetime.utcnow)
+    last_active_at = Column(DateTime, default=datetime.utcnow)
+    is_active = Column(Boolean, default=True)
+    
+    conversations = relationship("Conversation", back_populates="user")
+
+
+class Conversation(Base):
+    """对话会话"""
+    __tablename__ = 'conversations'
+    
+    id = Column(Integer, primary_key=True, index=True)
+    conversation_id = Column(String(100), unique=True, index=True)
+    user_id = Column(Integer, ForeignKey('users.id'))
+    channel_id = Column(Integer, ForeignKey('channels.id'), nullable=True)  # 新增渠道关联
+    
+    title = Column(String(200), nullable=True)
+    
+    # 当前使用的Agent（会话可切换Agent）
+    current_agent_id = Column(Integer, ForeignKey('agents.id'), nullable=True)
+    
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    is_active = Column(Boolean, default=True)
+    extra_data = Column(JSON, nullable=True)
+    
+    user = relationship("User", back_populates="conversations")
+    channel = relationship("Channel", back_populates="conversations")
+    messages = relationship("Message", back_populates="conversation")
+
+
+class Message(Base):
+    """消息表"""
+    __tablename__ = 'messages'
+    
+    id = Column(Integer, primary_key=True, index=True)
+    conversation_id = Column(Integer, ForeignKey('conversations.id'))
+    role = Column(String(20))  # user, assistant, system, thinking(思考过程)
+    content = Column(Text)
+    source = Column(String(20))  # web, matrix
+    
+    # 思考内容（如果启用了思考功能）
+    thinking_content = Column(Text, nullable=True)  # 思考过程
+    
+    # Agent信息
+    agent_id = Column(Integer, ForeignKey('agents.id'), nullable=True)  # 生成此消息的Agent
+    model_used = Column(String(100), nullable=True)  # 使用的模型
+    
+    created_at = Column(DateTime, default=datetime.utcnow)
+    extra_data = Column(JSON, nullable=True)
+    
+    conversation = relationship("Conversation", back_populates="messages")
+
+
+# ==================== Matrix房间映射（保留） ====================
+
+class MatrixRoomMapping(Base):
+    """Matrix房间映射"""
+    __tablename__ = 'matrix_room_mapping'
+    
+    id = Column(Integer, primary_key=True, index=True)
+    room_id = Column(String(200), unique=True, index=True)
+    user_id = Column(Integer, ForeignKey('users.id'))
+    conversation_id = Column(Integer, ForeignKey('conversations.id'))
+    channel_id = Column(Integer, ForeignKey('channels.id'), nullable=True)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+
+# ==================== 系统配置（保留） ====================
+
+class SystemConfig(Base):
+    """系统配置表"""
+    __tablename__ = 'system_config'
+    
+    id = Column(Integer, primary_key=True, index=True)
+    key = Column(String(100), unique=True, index=True)
+    value = Column(Text)
+    description = Column(String(500))
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+
+def init_db():
+    """初始化数据库"""
+    Base.metadata.create_all(bind=engine)
+
+
+def get_db():
+    """获取数据库会话"""
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+
+# ==================== 初始化默认数据 ====================
+
+def init_default_data():
+    """初始化默认数据：大模型池、Agent、渠道"""
+    db = SessionLocal()
+    try:
+        # 检查是否已有数据
+        if db.query(LLMProvider).count() > 0:
+            return
+        
+        # 1. 创建默认大模型池
+        default_llm = LLMProvider(
+            name="本地LLM Proxy",
+            api_base="http://192.168.2.17:19007/v1",
+            api_key="xxxx",
+            models=[
+                {"id": "auto", "name": "auto (自动选择)"},
+                {"id": "qwen3.5-4b", "name": "qwen3.5-4b"},
+                {"id": "dsv32", "name": "dsv32"},
+                {"id": "glm-4", "name": "glm-4"}
+            ],
+            default_model="auto",
+            supports_thinking=False,
+            is_active=True,
+            priority=0,
+            description="本地LLM代理服务"
+        )
+        db.add(default_llm)
+        
+        # 2. 创建默认Agent
+        default_agent = Agent(
+            name="default",
+            display_name="默认助手",
+            llm_provider_id=1,
+            system_prompt="你是一个有用的AI助手。",
+            enable_thinking=True,
+            thinking_prompt="请先仔细思考这个问题，然后给出回答。",
+            is_active=True,
+            is_default=True,
+            description="默认AI助手"
+        )
+        db.add(default_agent)
+        
+        # 3. 创建渠道
+        web_channel = Channel(
+            channel_type="web",
+            name="网页端",
+            config={"require_login": False},
+            is_active=True,
+            is_primary=True
+        )
+        db.add(web_channel)
+        
+        matrix_channel = Channel(
+            channel_type="matrix",
+            name="Matrix AI Bot",
+            config={
+                "homeserver": "http://matrix.tphai.com",
+                "username": "@tester:matrix.tphai.com",
+                "password": "tester12345@!"
+            },
+            is_active=True
+        )
+        db.add(matrix_channel)
+        
+        db.commit()
+        
+        # 4. 创建渠道-Agent映射
+        web_mapping = ChannelAgentMapping(
+            channel_id=1,
+            agent_id=1,
+            priority=0,
+            mode='single'
+        )
+        db.add(web_mapping)
+        
+        matrix_mapping = ChannelAgentMapping(
+            channel_id=2,
+            agent_id=1,
+            priority=0,
+            mode='single'
+        )
+        db.add(matrix_mapping)
+        
+        db.commit()
+        print("默认数据初始化完成")
+        
+    finally:
+        db.close()
\ No newline at end of file
diff --git a/services/__init__.py b/services/__init__.py
index 99774e3..8257e75 100644
--- a/services/__init__.py
+++ b/services/__init__.py
@@ -1,9 +1,24 @@
+# v1 服务（兼容）
 from .ai_service import ai_service, AIService
 from .conversation_service import ConversationService
-from .matrix_service import matrix_bot, MatrixBot
+
+# v2 服务
+from .llm_service import llm_service, LLMService
+from .agent_service import AgentService, LLMProviderService, ChannelService
+
+# Matrix服务
+try:
+    from .matrix_service_v2 import matrix_bot, MatrixBotV2
+except ImportError:
+    from .matrix_service import matrix_bot, MatrixBot
 
 __all__ = [
+    # v1
     'ai_service', 'AIService',
     'ConversationService',
-    'matrix_bot', 'MatrixBot'
+    # v2
+    'llm_service', 'LLMService',
+    'AgentService', 'LLMProviderService', 'ChannelService',
+    # Matrix
+    'matrix_bot', 'MatrixBotV2'
 ]
\ No newline at end of file
diff --git a/services/agent_service.py b/services/agent_service.py
new file mode 100644
index 0000000..9dfc476
--- /dev/null
+++ b/services/agent_service.py
@@ -0,0 +1,408 @@
+"""
+Agent管理服务
+"""
+from sqlalchemy.orm import Session
+from typing import List, Optional, Dict
+import logging
+
+from models_v2 import Agent, LLMProvider, ChannelAgentMapping, Channel, init_default_data
+
+logger = logging.getLogger(__name__)
+
+
+class AgentService:
+    """Agent管理服务"""
+    
+    def __init__(self, db: Session):
+        self.db = db
+    
+    def get_all_agents(self) -> List[Agent]:
+        """获取所有Agent"""
+        return self.db.query(Agent).order_by(Agent.is_default.desc(), Agent.name).all()
+    
+    def get_active_agents(self) -> List[Agent]:
+        """获取活跃的Agent"""
+        return self.db.query(Agent).filter(Agent.is_active == True).all()
+    
+    def get_agent(self, agent_id: int) -> Optional[Agent]:
+        """获取单个Agent"""
+        return self.db.query(Agent).filter(Agent.id == agent_id).first()
+    
+    def get_agent_by_name(self, name: str) -> Optional[Agent]:
+        """通过名称获取Agent"""
+        return self.db.query(Agent).filter(Agent.name == name).first()
+    
+    def get_default_agent(self) -> Optional[Agent]:
+        """获取默认Agent"""
+        agent = self.db.query(Agent).filter(Agent.is_default == True, Agent.is_active == True).first()
+        if not agent:
+            # 如果没有默认，获取第一个活跃的
+            agent = self.db.query(Agent).filter(Agent.is_active == True).first()
+        return agent
+    
+    def create_agent(self, data: Dict) -> Agent:
+        """创建Agent"""
+        agent = Agent(
+            name=data.get('name'),
+            display_name=data.get('display_name', data.get('name')),
+            llm_provider_id=data.get('llm_provider_id'),
+            model_override=data.get('model_override'),
+            system_prompt=data.get('system_prompt', '你是一个有用的AI助手。'),
+            enable_thinking=data.get('enable_thinking', True),
+            thinking_prompt=data.get('thinking_prompt'),
+            thinking_prefix=data.get('thinking_prefix', ''),
+            thinking_suffix=data.get('thinking_suffix', ''),
+            max_history=data.get('max_history', 20),
+            temperature_override=data.get('temperature_override'),
+            is_active=data.get('is_active', True),
+            is_default=data.get('is_default', False),
+            description=data.get('description')
+        )
+        self.db.add(agent)
+        self.db.commit()
+        self.db.refresh(agent)
+        return agent
+    
+    def update_agent(self, agent_id: int, data: Dict) -> Optional[Agent]:
+        """更新Agent"""
+        agent = self.get_agent(agent_id)
+        if not agent:
+            return None
+        
+        for key, value in data.items():
+            if hasattr(agent, key) and value is not None:
+                setattr(agent, key, value)
+        
+        self.db.commit()
+        self.db.refresh(agent)
+        return agent
+    
+    def delete_agent(self, agent_id: int) -> bool:
+        """删除Agent"""
+        agent = self.get_agent(agent_id)
+        if not agent:
+            return False
+        
+        # 如果是默认Agent，不允许删除
+        if agent.is_default:
+            return False
+        
+        self.db.delete(agent)
+        self.db.commit()
+        return True
+    
+    def set_default_agent(self, agent_id: int) -> bool:
+        """设置默认Agent"""
+        # 先清除所有默认
+        self.db.query(Agent).update({Agent.is_default: False})
+        
+        agent = self.get_agent(agent_id)
+        if not agent:
+            return False
+        
+        agent.is_default = True
+        self.db.commit()
+        return True
+    
+    def get_agent_config(self, agent_id: int) -> Dict:
+        """获取Agent完整配置（包含LLM Provider信息）"""
+        agent = self.get_agent(agent_id)
+        if not agent:
+            return {}
+        
+        provider = self.db.query(LLMProvider).filter(LLMProvider.id == agent.llm_provider_id).first()
+        
+        return {
+            'agent': {
+                'id': agent.id,
+                'name': agent.name,
+                'display_name': agent.display_name,
+                'system_prompt': agent.system_prompt,
+                'enable_thinking': agent.enable_thinking,
+                'thinking_prompt': agent.thinking_prompt,
+                'thinking_prefix': agent.thinking_prefix,
+                'thinking_suffix': agent.thinking_suffix,
+                'model_override': agent.model_override,
+                'max_history': agent.max_history,
+                'temperature_override': agent.temperature_override,
+                'is_default': agent.is_default,
+                'is_active': agent.is_active
+            },
+            'provider': {
+                'id': provider.id if provider else None,
+                'name': provider.name if provider else None,
+                'api_base': provider.api_base if provider else None,
+                'api_key': provider.api_key if provider else None,
+                'supports_thinking': provider.supports_thinking if provider else False,
+                'thinking_model': provider.thinking_model if provider else None,
+                'default_model': provider.default_model if provider else 'auto',
+                'max_tokens': provider.max_tokens if provider else 4096,
+                'temperature': provider.temperature if provider else 0.7,
+                'models': provider.models if provider else []
+            } if provider else {}
+        }
+    
+    def get_agent_for_channel(self, channel_id: int, conditions: Dict = None) -> Optional[Agent]:
+        """根据渠道获取Agent（支持优先级和条件）"""
+        mappings = self.db.query(ChannelAgentMapping).filter(
+            ChannelAgentMapping.channel_id == channel_id,
+            ChannelAgentMapping.is_active == True
+        ).order_by(ChannelAgentMapping.priority).all()
+        
+        if not mappings:
+            return self.get_default_agent()
+        
+        # 检查条件匹配
+        for mapping in mappings:
+            if conditions and mapping.conditions:
+                # 检查条件是否匹配
+                match = True
+                for key, value in conditions.items():
+                    if mapping.conditions.get(key) != value:
+                        match = False
+                        break
+                if match:
+                    return self.get_agent(mapping.agent_id)
+            else:
+                # 无条件或无条件映射，返回第一个
+                return self.get_agent(mappings.agent_id)
+        
+        # 没有匹配的，返回默认
+        return self.get_default_agent()
+
+
+class LLMProviderService:
+    """大模型池管理服务"""
+    
+    def __init__(self, db: Session):
+        self.db = db
+    
+    def get_all_providers(self) -> List[LLMProvider]:
+        """获取所有Provider"""
+        return self.db.query(LLMProvider).order_by(LLMProvider.priority, LLMProvider.name).all()
+    
+    def get_active_providers(self) -> List[LLMProvider]:
+        """获取活跃的Provider"""
+        return self.db.query(LLMProvider).filter(LLMProvider.is_active == True).all()
+    
+    def get_provider(self, provider_id: int) -> Optional[LLMProvider]:
+        """获取单个Provider"""
+        return self.db.query(LLMProvider).filter(LLMProvider.id == provider_id).first()
+    
+    def get_provider_by_name(self, name: str) -> Optional[LLMProvider]:
+        """通过名称获取Provider"""
+        return self.db.query(LLMProvider).filter(LLMProvider.name == name).first()
+    
+    def create_provider(self, data: Dict) -> LLMProvider:
+        """创建Provider"""
+        provider = LLMProvider(
+            name=data.get('name'),
+            api_base=data.get('api_base'),
+            api_key=data.get('api_key', ''),
+            models=data.get('models', []),
+            default_model=data.get('default_model', 'auto'),
+            supports_thinking=data.get('supports_thinking', False),
+            thinking_model=data.get('thinking_model'),
+            max_tokens=data.get('max_tokens', 4096),
+            temperature=data.get('temperature', 0.7),
+            is_active=data.get('is_active', True),
+            priority=data.get('priority', 0),
+            description=data.get('description')
+        )
+        self.db.add(provider)
+        self.db.commit()
+        self.db.refresh(provider)
+        return provider
+    
+    def update_provider(self, provider_id: int, data: Dict) -> Optional[LLMProvider]:
+        """更新Provider"""
+        provider = self.get_provider(provider_id)
+        if not provider:
+            return None
+        
+        for key, value in data.items():
+            if hasattr(provider, key) and value is not None:
+                setattr(provider, key, value)
+        
+        self.db.commit()
+        self.db.refresh(provider)
+        return provider
+    
+    def delete_provider(self, provider_id: int) -> bool:
+        """删除Provider"""
+        provider = self.get_provider(provider_id)
+        if not provider:
+            return False
+        
+        # 检查是否有Agent在使用
+        from models_v2 import Agent
+        agents_count = self.db.query(Agent).filter(Agent.llm_provider_id == provider_id).count()
+        if agents_count > 0:
+            return False
+        
+        self.db.delete(provider)
+        self.db.commit()
+        return True
+    
+    def get_provider_config(self, provider_id: int) -> Dict:
+        """获取Provider配置"""
+        provider = self.get_provider(provider_id)
+        if not provider:
+            return {}
+        
+        return {
+            'id': provider.id,
+            'name': provider.name,
+            'api_base': provider.api_base,
+            'api_key': provider.api_key,
+            'models': provider.models,
+            'default_model': provider.default_model,
+            'supports_thinking': provider.supports_thinking,
+            'thinking_model': provider.thinking_model,
+            'max_tokens': provider.max_tokens,
+            'temperature': provider.temperature,
+            'is_active': provider.is_active,
+            'priority': provider.priority,
+            'description': provider.description
+        }
+
+
+class ChannelService:
+    """渠道管理服务"""
+    
+    def __init__(self, db: Session):
+        self.db = db
+    
+    def get_all_channels(self) -> List[Channel]:
+        """获取所有渠道"""
+        return self.db.query(Channel).order_by(Channel.is_primary.desc(), Channel.channel_type).all()
+    
+    def get_active_channels(self) -> List[Channel]:
+        """获取活跃渠道"""
+        return self.db.query(Channel).filter(Channel.is_active == True).all()
+    
+    def get_channel(self, channel_id: int) -> Optional[Channel]:
+        """获取单个渠道"""
+        return self.db.query(Channel).filter(Channel.id == channel_id).first()
+    
+    def get_channel_by_type(self, channel_type: str) -> Optional[Channel]:
+        """获取指定类型的渠道"""
+        return self.db.query(Channel).filter(
+            Channel.channel_type == channel_type,
+            Channel.is_active == True
+        ).first()
+    
+    def get_web_channel(self) -> Optional[Channel]:
+        """获取网页渠道"""
+        return self.get_channel_by_type('web')
+    
+    def get_matrix_channel(self) -> Optional[Channel]:
+        """获取Matrix渠道"""
+        return self.get_channel_by_type('matrix')
+    
+    def create_channel(self, data: Dict) -> Channel:
+        """创建渠道"""
+        channel = Channel(
+            channel_type=data.get('channel_type'),
+            name=data.get('name'),
+            config=data.get('config', {}),
+            is_active=data.get('is_active', True),
+            is_primary=data.get('is_primary', False)
+        )
+        self.db.add(channel)
+        self.db.commit()
+        self.db.refresh(channel)
+        return channel
+    
+    def update_channel(self, channel_id: int, data: Dict) -> Optional[Channel]:
+        """更新渠道"""
+        channel = self.get_channel(channel_id)
+        if not channel:
+            return None
+        
+        for key, value in data.items():
+            if hasattr(channel, key) and value is not None:
+                setattr(channel, key, value)
+        
+        self.db.commit()
+        self.db.refresh(channel)
+        return channel
+    
+    def delete_channel(self, channel_id: int) -> bool:
+        """删除渠道"""
+        channel = self.get_channel(channel_id)
+        if not channel:
+            return False
+        
+        # 检查是否是主渠道
+        if channel.is_primary:
+            return False
+        
+        self.db.delete(channel)
+        self.db.commit()
+        return True
+    
+    def bind_agent(self, channel_id: int, agent_id: int, priority: int = 0, mode: str = 'single', conditions: Dict = None) -> ChannelAgentMapping:
+        """绑定Agent到渠道"""
+        mapping = ChannelAgentMapping(
+            channel_id=channel_id,
+            agent_id=agent_id,
+            priority=priority,
+            mode=mode,
+            conditions=conditions,
+            is_active=True
+        )
+        self.db.add(mapping)
+        self.db.commit()
+        self.db.refresh(mapping)
+        return mapping
+    
+    def unbind_agent(self, mapping_id: int) -> bool:
+        """解绑Agent"""
+        mapping = self.db.query(ChannelAgentMapping).filter(ChannelAgentMapping.id == mapping_id).first()
+        if not mapping:
+            return False
+        
+        self.db.delete(mapping)
+        self.db.commit()
+        return True
+    
+    def get_channel_agents(self, channel_id: int) -> List[Dict]:
+        """获取渠道绑定的所有Agent"""
+        mappings = self.db.query(ChannelAgentMapping).filter(
+            ChannelAgentMapping.channel_id == channel_id
+        ).order_by(ChannelAgentMapping.priority).all()
+        
+        result = []
+        for mapping in mappings:
+            agent = self.db.query(Agent).filter(Agent.id == mapping.agent_id).first()
+            if agent:
+                result.append({
+                    'mapping_id': mapping.id,
+                    'priority': mapping.priority,
+                    'mode': mapping.mode,
+                    'conditions': mapping.conditions,
+                    'agent': {
+                        'id': agent.id,
+                        'name': agent.name,
+                        'display_name': agent.display_name,
+                        'is_active': agent.is_active
+                    }
+                })
+        return result
+    
+    def get_channel_config(self, channel_id: int) -> Dict:
+        """获取渠道完整配置"""
+        channel = self.get_channel(channel_id)
+        if not channel:
+            return {}
+        
+        return {
+            'id': channel.id,
+            'channel_type': channel.channel_type,
+            'name': channel.name,
+            'config': channel.config,
+            'is_active': channel.is_active,
+            'is_primary': channel.is_primary,
+            'agent_mappings': self.get_channel_agents(channel_id)
+        }
\ No newline at end of file
diff --git a/services/conversation_service.py b/services/conversation_service.py
index 46285ed..6998970 100644
--- a/services/conversation_service.py
+++ b/services/conversation_service.py
@@ -1,17 +1,25 @@
 """
-会话管理服务
+会话管理服务 - v2.0 兼容版
+支持思考内容、Agent追踪等新字段
 """
 from typing import List, Optional
 from datetime import datetime
 from sqlalchemy.orm import Session
 import uuid
 
-from models import User, Conversation, Message
+# 兼容v1和v2模型
+try:
+    from models_v2 import User, Conversation, Message, Agent
+    USE_V2 = True
+except ImportError:
+    from models import User, Conversation, Message
+    USE_V2 = False
 
 
 class ConversationService:
     def __init__(self, db: Session):
         self.db = db
+        self.use_v2 = USE_V2
     
     def get_or_create_user(self, user_id: str, display_name: str = None, user_type: str = 'web', matrix_user_id: str = None) -> User:
         """获取或创建用户"""
@@ -31,14 +39,24 @@ class ConversationService:
             self.db.commit()
         return user
     
-    def create_conversation(self, user_id: int, title: str = None) -> Conversation:
+    def create_conversation(self, user_id: int, title: str = None, channel_id: int = None) -> Conversation:
         """创建新会话"""
         conversation_id = f"conv_{uuid.uuid4().hex[:12]}"
-        conversation = Conversation(
-            conversation_id=conversation_id,
-            user_id=user_id,
-            title=title
-        )
+        
+        if self.use_v2:
+            conversation = Conversation(
+                conversation_id=conversation_id,
+                user_id=user_id,
+                title=title,
+                channel_id=channel_id
+            )
+        else:
+            conversation = Conversation(
+                conversation_id=conversation_id,
+                user_id=user_id,
+                title=title
+            )
+        
         self.db.add(conversation)
         self.db.commit()
         self.db.refresh(conversation)
@@ -57,15 +75,39 @@ class ConversationService:
             Conversation.is_active == True
         ).order_by(Conversation.updated_at.desc()).all()
     
-    def add_message(self, conversation_id: int, role: str, content: str, source: str = 'web', extra_data: dict = None) -> Message:
+    def add_message(
+        self, 
+        conversation_id: int, 
+        role: str, 
+        content: str, 
+        source: str = 'web',
+        extra_data: dict = None,
+        thinking_content: str = None,  # v2新增
+        agent_id: int = None,  # v2新增
+        model_used: str = None  # v2新增
+    ) -> Message:
         """添加消息"""
-        message = Message(
-            conversation_id=conversation_id,
-            role=role,
-            content=content,
-            source=source,
-            extra_data=extra_data
-        )
+        
+        if self.use_v2:
+            message = Message(
+                conversation_id=conversation_id,
+                role=role,
+                content=content,
+                source=source,
+                extra_data=extra_data,
+                thinking_content=thinking_content,
+                agent_id=agent_id,
+                model_used=model_used
+            )
+        else:
+            message = Message(
+                conversation_id=conversation_id,
+                role=role,
+                content=content,
+                source=source,
+                extra_data=extra_data
+            )
+        
         self.db.add(message)
         
         # 更新会话时间
@@ -75,6 +117,10 @@ class ConversationService:
             # 如果没有标题，用第一条用户消息作为标题
             if not conversation.title and role == 'user':
                 conversation.title = content[:50] + ('...' if len(content) > 50 else '')
+            
+            # v2: 更新当前Agent
+            if self.use_v2 and agent_id:
+                conversation.current_agent_id = agent_id
         
         self.db.commit()
         self.db.refresh(message)
@@ -93,7 +139,8 @@ class ConversationService:
             return []
         
         messages = self.db.query(Message).filter(
-            Message.conversation_id == conversation.id
+            Message.conversation_id == conversation.id,
+            Message.role.in_(['user', 'assistant', 'system'])  # 排除thinking
         ).order_by(Message.created_at.desc()).limit(limit).all()
         
         # 反转顺序，最早的在前
@@ -108,4 +155,16 @@ class ConversationService:
             conversation.is_active = False
             self.db.commit()
             return True
+        return False
+    
+    def set_conversation_agent(self, conversation_id: str, agent_id: int):
+        """设置会话使用的Agent（v2）"""
+        if not self.use_v2:
+            return False
+        
+        conversation = self.get_conversation(conversation_id)
+        if conversation:
+            conversation.current_agent_id = agent_id
+            self.db.commit()
+            return True
         return False
\ No newline at end of file
diff --git a/services/llm_service.py b/services/llm_service.py
new file mode 100644
index 0000000..ff17a62
--- /dev/null
+++ b/services/llm_service.py
@@ -0,0 +1,319 @@
+"""
+LLM服务 - 大模型池管理，支持思考功能
+"""
+import httpx
+from typing import List, Dict, AsyncGenerator, Optional, Tuple
+import json
+import logging
+import re
+
+logger = logging.getLogger(__name__)
+
+
+class LLMService:
+    """大模型调用服务，支持思考功能"""
+    
+    def __init__(self):
+        self.providers_cache = {}  # 缓存Provider配置
+    
+    def load_provider(self, provider_config: dict):
+        """加载Provider配置"""
+        provider_id = provider_config.get('id')
+        self.providers_cache[provider_id] = {
+            'api_base': provider_config.get('api_base'),
+            'api_key': provider_config.get('api_key'),
+            'supports_thinking': provider_config.get('supports_thinking', False),
+            'thinking_model': provider_config.get('thinking_model'),
+            'default_model': provider_config.get('default_model'),
+            'max_tokens': provider_config.get('max_tokens', 4096),
+            'temperature': provider_config.get('temperature', 0.7)
+        }
+    
+    async def get_available_models(self, api_base: str, api_key: str) -> List[dict]:
+        """从API获取可用模型列表"""
+        if not api_base:
+            return []
+        
+        try:
+            url = f"{api_base}/models"
+            headers = {"Authorization": f"Bearer {api_key}"}
+            
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                response = await client.get(url, headers=headers)
+                if response.status_code == 200:
+                    data = response.json()
+                    models = []
+                    for m in data.get('data', []):
+                        model_id = m.get('id', '')
+                        if model_id:
+                            models.append({
+                                "id": model_id,
+                                "name": m.get('name', model_id),
+                                "owned_by": m.get('owned_by', 'unknown')
+                            })
+                    return models
+        except Exception as e:
+            logger.warning(f"获取模型列表失败: {e}")
+        
+        return []
+    
+    async def test_connection(self, api_base: str, api_key: str, model: str) -> dict:
+        """测试API连接"""
+        try:
+            url = f"{api_base}/chat/completions"
+            headers = {
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json"
+            }
+            payload = {
+                "model": model,
+                "messages": [{"role": "user", "content": "测试连接"}],
+                "max_tokens": 50
+            }
+            
+            async with httpx.AsyncClient(timeout=15.0) as client:
+                response = await client.post(url, headers=headers, json=payload)
+                if response.status_code == 200:
+                    data = response.json()
+                    content = data['choices'][0]['message']['content']
+                    return {
+                        "success": True,
+                        "message": f"连接成功！模型响应: {content[:100]}",
+                        "model": model
+                    }
+                else:
+                    return {
+                        "success": False,
+                        "message": f"连接失败: HTTP {response.status_code}"
+                    }
+        except httpx.ConnectError:
+            return {"success": False, "message": f"无法连接到API地址"}
+        except httpx.TimeoutException:
+            return {"success": False, "message": "连接超时"}
+        except Exception as e:
+            return {"success": False, "message": f"连接失败: {str(e)}"}
+    
+    async def chat(
+        self,
+        messages: List[Dict],
+        provider_config: dict,
+        agent_config: dict,
+        enable_thinking: bool = True
+    ) -> Tuple[str, Optional[str]]:
+        """
+        调用AI模型进行对话
+        
+        Returns:
+            Tuple[str, Optional[str]]: (回复内容, 思考过程)
+        """
+        api_base = provider_config.get('api_base')
+        api_key = provider_config.get('api_key')
+        model = agent_config.get('model_override') or provider_config.get('default_model', 'auto')
+        supports_thinking = provider_config.get('supports_thinking', False)
+        thinking_model = provider_config.get('thinking_model')
+        
+        max_tokens = provider_config.get('max_tokens', 4096)
+        temperature = agent_config.get('temperature_override') or provider_config.get('temperature', 0.7)
+        
+        # 构建消息
+        final_messages = messages.copy()
+        
+        # 添加系统提示
+        system_prompt = agent_config.get('system_prompt', '你是一个有用的AI助手。')
+        if final_messages and final_messages[0]['role'] != 'system':
+            final_messages.insert(0, {"role": "system", "content": system_prompt})
+        
+        thinking_content = None
+        
+        # 处理思考功能
+        if enable_thinking and agent_config.get('enable_thinking', True):
+            thinking_prompt = agent_config.get('thinking_prompt')
+            
+            if supports_thinking and thinking_model:
+                # 使用专门的思考模型
+                thinking_messages = final_messages.copy()
+                if thinking_prompt:
+                    thinking_messages.append({"role": "system", "content": thinking_prompt})
+                
+                try:
+                    thinking_result = await self._call_api(
+                        api_base, api_key, thinking_model, thinking_messages,
+                        max_tokens=min(max_tokens, 1000),
+                        temperature=0.3  # 思考时降低温度
+                    )
+                    thinking_content = thinking_result
+                except Exception as e:
+                    logger.warning(f"思考模型调用失败: {e}")
+            
+            elif supports_thinking:
+                # Provider支持思考但无单独模型，尝试在回复中获取思考部分
+                pass  # 在回复解析时处理
+            
+            elif thinking_prompt:
+                # Provider不支持思考，但Agent配置了思考提示词
+                # 将思考提示词添加到系统提示
+                enhanced_system = f"{system_prompt}\n\n在回答之前，请先思考问题。思考过程请用{agent_config.get('thinking_prefix', '')}和{agent_config.get('thinking_suffix', '')}包裹，然后再给出正式回答。"
+                if thinking_prompt:
+                    enhanced_system += f"\n思考指导：{thinking_prompt}"
+                final_messages[0] = {"role": "system", "content": enhanced_system}
+        
+        # 调用主模型
+        try:
+            response = await self._call_api(
+                api_base, api_key, model, final_messages,
+                max_tokens=max_tokens,
+                temperature=temperature
+            )
+            
+            # 尝试从回复中提取思考内容
+            if enable_thinking and not supports_thinking:
+                thinking_prefix = agent_config.get('thinking_prefix', '')
+                thinking_suffix = agent_config.get('thinking_suffix', '')
+                
+                if thinking_prefix and thinking_suffix:
+                    # 提取思考部分
+                    pattern = f"{re.escape(thinking_prefix)}(.*?)?{re.escape(thinking_suffix)}"
+                    match = re.search(pattern, response, re.DOTALL)
+                    if match:
+                        thinking_content = match.group(1).strip()
+                        # 移除思考部分，只保留回复
+                        response = re.sub(pattern, '', response, flags=re.DOTALL).strip()
+            
+            return response, thinking_content
+            
+        except Exception as e:
+            logger.error(f"LLM调用失败: {e}")
+            raise
+    
+    async def _call_api(
+        self,
+        api_base: str,
+        api_key: str,
+        model: str,
+        messages: List[Dict],
+        max_tokens: int = 4096,
+        temperature: float = 0.7
+    ) -> str:
+        """调用API"""
+        url = f"{api_base}/chat/completions"
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+        payload = {
+            "model": model,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens
+        }
+        
+        logger.info(f"调用LLM: url={url}, model={model}")
+        
+        async with httpx.AsyncClient(timeout=60.0) as client:
+            response = await client.post(url, headers=headers, json=payload)
+            response.raise_for_status()
+            data = response.json()
+            return data['choices'][0]['message']['content']
+    
+    async def chat_stream(
+        self,
+        messages: List[Dict],
+        provider_config: dict,
+        agent_config: dict,
+        enable_thinking: bool = True
+    ) -> AsyncGenerator[dict, None]:
+        """
+        流式调用AI模型
+        
+        Yields:
+            dict: {"type": "thinking"|"content", "text": "..."}
+        """
+        api_base = provider_config.get('api_base')
+        api_key = provider_config.get('api_key')
+        model = agent_config.get('model_override') or provider_config.get('default_model', 'auto')
+        max_tokens = provider_config.get('max_tokens', 4096)
+        temperature = agent_config.get('temperature_override') or provider_config.get('temperature', 0.7)
+        
+        # 构建消息
+        final_messages = messages.copy()
+        system_prompt = agent_config.get('system_prompt', '你是一个有用的AI助手。')
+        if final_messages and final_messages[0]['role'] != 'system':
+            final_messages.insert(0, {"role": "system", "content": system_prompt})
+        
+        # 如果启用思考但模型不支持
+        if enable_thinking and agent_config.get('enable_thinking', True):
+            supports_thinking = provider_config.get('supports_thinking', False)
+            thinking_prompt = agent_config.get('thinking_prompt')
+            
+            if not supports_thinking and thinking_prompt:
+                thinking_prefix = agent_config.get('thinking_prefix', '')
+                thinking_suffix = agent_config.get('thinking_suffix', '')
+                enhanced_system = f"{system_prompt}\n\n在回答之前，请先思考问题。思考过程请用{thinking_prefix}和{thinking_suffix}包裹，然后再给出正式回答。"
+                if thinking_prompt:
+                    enhanced_system += f"\n思考指导：{thinking_prompt}"
+                final_messages[0] = {"role": "system", "content": enhanced_system}
+        
+        url = f"{api_base}/chat/completions"
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+        payload = {
+            "model": model,
+            "messages": final_messages,
+            "stream": True,
+            "temperature": temperature,
+            "max_tokens": max_tokens
+        }
+        
+        thinking_prefix = agent_config.get('thinking_prefix', '')
+        thinking_suffix = agent_config.get('thinking_suffix', '')
+        in_thinking = False
+        thinking_buffer = ""
+        
+        async with httpx.AsyncClient(timeout=60.0) as client:
+            async with client.stream("POST", url, headers=headers, json=payload) as response:
+                async for line in response.aiter_lines():
+                    if line.startswith("data: "):
+                        data_str = line[6:]
+                        if data_str == "[DONE]":
+                            break
+                        try:
+                            data = json.loads(data_str)
+                            if 'choices' in data and len(data['choices']) > 0:
+                                delta = data['choices'][0].get('delta', {})
+                                if 'content' in delta:
+                                    text = delta['content']
+                                    
+                                    # 检测思考部分
+                                    if thinking_prefix and thinking_suffix:
+                                        for char in text:
+                                            if in_thinking:
+                                                thinking_buffer += char
+                                                # 检查是否结束思考
+                                                if thinking_buffer.endswith(thinking_suffix):
+                                                    thinking_content = thinking_buffer[:-len(thinking_suffix)]
+                                                    yield {"type": "thinking", "text": thinking_content}
+                                                    in_thinking = False
+                                                    thinking_buffer = ""
+                                                else:
+                                                    # 检查是否接近结束
+                                                    suffix_len = len(thinking_suffix)
+                                                    if len(thinking_buffer) >= suffix_len:
+                                                        yield {"type": "thinking", "text": thinking_buffer[-suffix_len:]}
+                                            else:
+                                                if char == thinking_prefix[0]:
+                                                    # 可能开始思考
+                                                    thinking_buffer = char
+                                                    if len(thinking_prefix) == 1:
+                                                        in_thinking = True
+                                                else:
+                                                    yield {"type": "content", "text": char}
+                                    else:
+                                        yield {"type": "content", "text": text}
+                        except json.JSONDecodeError:
+                            continue
+
+
+# 全局实例
+llm_service = LLMService()
\ No newline at end of file
diff --git a/services/matrix_service_v2.py b/services/matrix_service_v2.py
new file mode 100644
index 0000000..6fa80bf
--- /dev/null
+++ b/services/matrix_service_v2.py
@@ -0,0 +1,370 @@
+"""
+Matrix Bot 服务 v2.0 - 使用Agent架构
+支持渠道独立Agent绑定
+"""
+import asyncio
+import logging
+import os
+from typing import Optional, Callable
+from nio import AsyncClient, RoomMessageText, MegolmEvent
+
+from models_v2 import SessionLocal, User, Conversation, Message, SystemConfig, Agent, Channel, ChannelAgentMapping
+from services.conversation_service import ConversationService
+from services.agent_service import AgentService, ChannelService
+from services.llm_service import llm_service
+
+logger = logging.getLogger(__name__)
+
+MAIN_USER_ID = "main_user"
+STORE_PATH = "/home/xian/.openclaw/workspace-coder/works/ai-chat/matrix_store"
+
+
+class MatrixBotV2:
+    """Matrix Bot v2.0 - 支持Agent架构"""
+    
+    def __init__(self):
+        self.client: Optional[AsyncClient] = None
+        self.homeserver: str = ""
+        self.user_id: str = ""
+        self.password: str = ""
+        self.is_running: bool = False
+        self.on_message_callback: Optional[Callable] = None
+        self.last_room_id: str = ""
+        self.processed_events: set = set()
+        self.channel_id: Optional[int] = None  # Matrix渠道ID
+    
+    async def init_from_config(self):
+        """从渠道配置初始化"""
+        db = SessionLocal()
+        try:
+            # 获取Matrix渠道配置
+            channel_service = ChannelService(db)
+            channel = channel_service.get_channel_by_type('matrix')
+            
+            if not channel or not channel.is_active:
+                logger.warning("Matrix渠道未配置或未启用")
+                return False
+            
+            self.channel_id = channel.id
+            
+            # 从渠道配置获取Matrix参数
+            config = channel.config or {}
+            self.homeserver = config.get('homeserver', 'http://matrix.tphai.com')
+            self.user_id = config.get('username', '@tester:matrix.tphai.com')
+            self.password = config.get('password', 'tester12345@!')
+            
+            logger.info(f"Matrix配置: homeserver={self.homeserver}, user={self.user_id}")
+            
+            if self.user_id and self.password:
+                os.makedirs(STORE_PATH, exist_ok=True)
+                
+                self.client = AsyncClient(
+                    self.homeserver,
+                    self.user_id,
+                    store_path=STORE_PATH
+                )
+                self.is_running = True
+                logger.info(f"Matrix nio 客户端已初始化")
+                return True
+        finally:
+            db.close()
+        return False
+    
+    async def start_sync(self, message_handler: Callable = None):
+        """开始同步消息"""
+        if not self.is_running or not self.client:
+            logger.warning("Matrix未连接")
+            return
+        
+        self.on_message_callback = message_handler
+        
+        try:
+            login_resp = await self.client.login(self.password)
+            logger.info(f"Matrix登录成功: {login_resp}")
+            
+            sync_resp = await self.client.sync(full_state=True)
+            logger.info(f"初始同步完成: next_batch={sync_resp.next_batch}")
+            
+            self.client.add_event_callback(self._handle_nio_message, RoomMessageText)
+            self.client.add_event_callback(self._handle_encrypted_message, MegolmEvent)
+            
+            logger.info("Matrix消息回调已注册")
+            
+            asyncio.create_task(self._run_sync_forever())
+            logger.info("Matrix nio sync_forever 任务已启动")
+        except Exception as e:
+            logger.error(f"Matrix启动失败: {e}")
+            import traceback
+            logger.error(traceback.format_exc())
+    
+    async def _run_sync_forever(self):
+        """运行 sync_forever"""
+        try:
+            logger.info("开始 Matrix sync_forever...")
+            await self.client.sync_forever(timeout=30000)
+        except Exception as e:
+            logger.error(f"sync_forever 错误: {e}")
+            self.is_running = False
+    
+    async def _handle_encrypted_message(self, room, event):
+        """处理加密消息"""
+        logger.info(f"收到加密消息: [{room.room_id}] event_id={event.event_id}")
+        
+        try:
+            body = None
+            sender = event.sender
+            
+            if event.decrypted:
+                try:
+                    decrypted_event = event.parse_decrypted_event(event.decrypted)
+                    if decrypted_event and hasattr(decrypted_event, 'body'):
+                        body = decrypted_event.body
+                        sender = decrypted_event.sender if hasattr(decrypted_event, 'sender') else event.sender
+                except Exception as e:
+                    logger.warning(f"parse_decrypted_event 失败: {e}")
+            
+            if not body and hasattr(event, 'source') and event.source:
+                content = event.source.get('content', {})
+                if 'body' in content:
+                    body = content.get('body', '')
+                    sender = event.source.get('sender', event.sender)
+            
+            if not body and hasattr(event, 'body') and event.body:
+                body = event.body
+            
+            if body:
+                logger.info(f"解密成功: sender={sender}, body={body[:50]}")
+                await self._process_message(room, sender, body, event.event_id)
+            else:
+                logger.warning(f"加密消息无法解密: event_id={event.event_id}")
+                    
+        except Exception as e:
+            logger.error(f"处理加密消息失败: {e}")
+    
+    async def _handle_nio_message(self, room, event):
+        """处理普通文本消息"""
+        sender = event.sender
+        if sender == self.user_id:
+            return
+        
+        message_text = event.body.strip()
+        logger.info(f"Matrix收到文本消息: [{room.room_id}] {sender}: {message_text}")
+        
+        await self._process_message(room, sender, message_text, event.event_id)
+    
+    async def _process_message(self, room, sender, message_text, event_id):
+        """处理消息核心逻辑"""
+        if event_id in self.processed_events:
+            return
+        
+        self.processed_events.add(event_id)
+        if len(self.processed_events) > 100:
+            self.processed_events = set(list(self.processed_events)[-50:])
+        
+        if sender == self.user_id:
+            return
+        
+        self.last_room_id = room.room_id
+        
+        db = SessionLocal()
+        try:
+            conv_service = ConversationService(db)
+            agent_service = AgentService(db)
+            channel_service = ChannelService(db)
+            
+            # 获取或创建主用户
+            main_user = conv_service.get_or_create_user(
+                MAIN_USER_ID,
+                display_name="主用户",
+                user_type='web'
+            )
+            
+            # 获取Matrix渠道绑定的Agent
+            agent = agent_service.get_agent_for_channel(self.channel_id)
+            
+            if not agent:
+                agent = agent_service.get_default_agent()
+            
+            agent_config = agent_service.get_agent_config(agent.id) if agent else None
+            
+            # 处理命令
+            if message_text == "/new":
+                conversation = conv_service.create_conversation(
+                    main_user.id, 
+                    channel_id=self.channel_id
+                )
+                await self.send_message(room.room_id, "✅ 已创建新会话")
+                logger.info(f"Matrix创建新会话: {conversation.conversation_id}")
+                
+                if self.on_message_callback:
+                    await self.on_message_callback(
+                        action="new_conversation",
+                        conversation_id=conversation.conversation_id,
+                        room_id=room.room_id
+                    )
+                return
+            
+            # 处理Agent切换命令
+            if message_text.startswith("/agent "):
+                agent_name = message_text[7:].strip()
+                new_agent = agent_service.get_agent_by_name(agent_name)
+                if new_agent and new_agent.is_active:
+                    await self.send_message(room.room_id, f"✅ 已切换到Agent: {new_agent.display_name}")
+                    # TODO: 更新会话Agent
+                else:
+                    await self.send_message(room.room_id, f"❌ Agent '{agent_name}' 不存在或未启用")
+                return
+            
+            # 处理思考开关命令
+            enable_thinking = True
+            if message_text == "/thinking off":
+                enable_thinking = False
+                await self.send_message(room.room_id, "✅ 思考功能已关闭")
+                return
+            elif message_text == "/thinking on":
+                enable_thinking = True
+                await self.send_message(room.room_id, "✅ 思考功能已开启")
+                return
+            
+            # 获取最新会话
+            conversations = conv_service.get_user_conversations(main_user.id)
+            if not conversations:
+                conversation = conv_service.create_conversation(main_user.id, channel_id=self.channel_id)
+            else:
+                conversation = conversations[0]
+            
+            # 保存用户消息
+            user_msg = conv_service.add_message(
+                conversation_id=conversation.id,
+                role='user',
+                content=message_text,
+                source='matrix',
+                extra_data={
+                    'event_id': event_id,
+                    'room_id': room.room_id,
+                    'sender': sender
+                }
+            )
+            
+            # 通知网页端
+            if self.on_message_callback:
+                await self.on_message_callback(
+                    action="user_message",
+                    conversation_id=conversation.conversation_id,
+                    user_message=message_text,
+                    room_id=room.room_id,
+                    message_id=user_msg.id,
+                    sender=sender
+                )
+            
+            # 调用AI生成回复
+            if agent_config and agent_config.get('provider'):
+                try:
+                    await self.client.room_typing(room.room_id, typing_state=True)
+                    
+                    history = conv_service.get_conversation_history(
+                        conversation.conversation_id, 
+                        limit=agent_config['agent'].get('max_history', 20)
+                    )
+                    
+                    # 调用LLM
+                    response, thinking_content = await llm_service.chat(
+                        messages=history,
+                        provider_config=agent_config['provider'],
+                        agent_config=agent_config['agent'],
+                        enable_thinking=enable_thinking and agent_config['agent'].get('enable_thinking', True)
+                    )
+                    
+                    # 保存AI回复
+                    assistant_msg = conv_service.add_message(
+                        conversation_id=conversation.id,
+                        role='assistant',
+                        content=response,
+                        source='matrix',
+                        thinking_content=thinking_content,
+                        agent_id=agent.id,
+                        model_used=agent_config['provider'].get('default_model')
+                    )
+                    
+                    # 发送回复到Matrix
+                    await self.send_message(room.room_id, response)
+                    
+                    await self.client.room_typing(room.room_id, typing_state=False)
+                    
+                    # 同步到网页端
+                    if self.on_message_callback:
+                        await self.on_message_callback(
+                            action="assistant_message",
+                            conversation_id=conversation.conversation_id,
+                            room_id=room.room_id,
+                            message_id=assistant_msg.id,
+                            content=response,
+                            thinking_content=thinking_content,
+                            agent_id=agent.id,
+                            agent_name=agent_config['agent'].get('display_name')
+                        )
+                    
+                    logger.info(f"Matrix AI回复已发送: {response[:50]}")
+                    
+                except Exception as e:
+                    logger.error(f"AI调用失败: {e}")
+                    await self.send_message(room.room_id, f"处理消息时出错: {str(e)}")
+                    await self.client.room_typing(room.room_id, typing_state=False)
+            else:
+                await self.send_message(room.room_id, "❌ Agent配置不完整，无法生成回复")
+            
+        except Exception as e:
+            logger.error(f"处理Matrix消息失败: {e}")
+            import traceback
+            logger.error(traceback.format_exc())
+            await self.send_message(room.room_id, f"处理消息时出错: {str(e)}")
+        finally:
+            db.close()
+    
+    async def send_message(self, room_id: str, message: str):
+        """发送消息到Matrix房间"""
+        if not self.client:
+            logger.error("Matrix客户端未初始化")
+            return False
+        
+        try:
+            await self.client.room_send(
+                room_id,
+                "m.room.message",
+                {"msgtype": "m.text", "body": message}
+            )
+            logger.info(f"Matrix消息发送成功: {room_id}")
+            return True
+        except Exception as e:
+            error_str = str(e)
+            if "not verified" in error_str or "OlmUnverifiedDeviceError" in error_str:
+                logger.warning(f"设备未验证: {e}")
+                try:
+                    for user_id, devices in self.client.device_store.items():
+                        for device_id, device in devices.items():
+                            if not device.verified:
+                                logger.info(f"验证设备: {user_id} {device_id}")
+                                self.client.verify_device(device)
+                    
+                    await self.client.room_send(
+                        room_id,
+                        "m.room.message",
+                        {"msgtype": "m.text", "body": message}
+                    )
+                    return True
+                except Exception as e2:
+                    logger.error(f"验证设备后发送仍失败: {e2}")
+                    return False
+            else:
+                logger.error(f"发送Matrix消息错误: {e}")
+                return False
+    
+    async def disconnect(self):
+        """断开连接"""
+        self.is_running = False
+        if self.client:
+            await self.client.close()
+
+
+# 全局实例
+matrix_bot = MatrixBotV2()
\ No newline at end of file
diff --git a/start_v2.sh b/start_v2.sh
new file mode 100755
index 0000000..07cb804
--- /dev/null
+++ b/start_v2.sh
@@ -0,0 +1,29 @@
+#!/bin/bash
+# AI对话系统 v2.0.0 启动脚本
+
+cd /home/xian/.openclaw/workspace-coder/works/ai-chat
+
+# 停止旧版本（如果在运行）
+./stop.sh 2>/dev/null
+
+# 创建必要目录
+mkdir -p static/css static/js logs matrix_store
+
+# 启动新版本服务
+nohup python3 main_v2.py > logs/ai-chat-v2.log 2>&1 &
+sleep 2
+
+# 检查服务状态
+if curl -s http://localhost:19020/api/v2/providers > /dev/null 2>&1; then
+    echo "✅ AI对话系统 v2.0.0 启动成功 (端口: 19020)"
+    echo "   网页端: http://localhost:19020"
+    echo "   后台管理: http://localhost:19020/admin"
+    echo ""
+    echo "   v2新功能:"
+    echo "   - 大模型池管理: 多个LLM Provider配置"
+    echo "   - Agent管理: 系统设定、思考功能开关"
+    echo "   - 渠道独立: 网页端/Matrix独立绑定Agent"
+else
+    echo "❌ 启动失败，查看日志:"
+    cat logs/ai-chat-v2.log | tail -30
+fi
\ No newline at end of file
diff --git a/templates/admin_v2/index.html b/templates/admin_v2/index.html
new file mode 100644
index 0000000..f62d87a
--- /dev/null
+++ b/templates/admin_v2/index.html
@@ -0,0 +1,1119 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AI对话系统 v2.0 - 后台管理</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css" rel="stylesheet">
+    <link href="https://cdn.jsdelivr.net/npm/remixicon@3.5.0/fonts/remixicon.css" rel="stylesheet">
+    <style>
+        :root {
+            --sidebar-width: 240px;
+        }
+        body {
+            background: #f5f7fa;
+        }
+        .sidebar {
+            position: fixed;
+            left: 0;
+            top: 0;
+            width: var(--sidebar-width);
+            height: 100vh;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 20px 0;
+        }
+        .sidebar .logo {
+            padding: 0 20px 30px;
+            border-bottom: 1px solid rgba(255,255,255,0.1);
+        }
+        .sidebar .logo h4 {
+            margin: 0;
+            font-size: 18px;
+        }
+        .sidebar .logo .version {
+            font-size: 12px;
+            color: rgba(255,255,255,0.7);
+        }
+        .sidebar .nav-item {
+            padding: 10px 20px;
+            cursor: pointer;
+            transition: all 0.2s;
+        }
+        .sidebar .nav-item:hover {
+            background: rgba(255,255,255,0.1);
+        }
+        .sidebar .nav-item.active {
+            background: rgba(255,255,255,0.2);
+            border-left: 3px solid white;
+        }
+        .sidebar .nav-item i {
+            margin-right: 10px;
+        }
+        .main-content {
+            margin-left: var(--sidebar-width);
+            padding: 30px;
+        }
+        .page-header {
+            margin-bottom: 30px;
+        }
+        .page-header h2 {
+            margin: 0;
+            font-size: 24px;
+        }
+        .card {
+            border: none;
+            border-radius: 12px;
+            box-shadow: 0 2px 12px rgba(0,0,0,0.08);
+        }
+        .card-header {
+            background: white;
+            border-bottom: 1px solid #eee;
+            padding: 15px 20px;
+        }
+        .btn-primary {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            border: none;
+        }
+        .btn-primary:hover {
+            background: linear-gradient(135deg, #5a6fd6 0%, #6a4190 100%);
+        }
+        .table th {
+            background: #f8f9fa;
+            font-weight: 600;
+        }
+        .badge-active {
+            background: #28a745;
+        }
+        .badge-inactive {
+            background: #6c757d;
+        }
+        .badge-default {
+            background: #ffc107;
+            color: #212529;
+        }
+        .thinking-toggle {
+            width: 50px;
+        }
+        .thinking-toggle .form-check-input {
+            width: 40px;
+            height: 20px;
+        }
+        .page-section {
+            display: none;
+        }
+        .page-section.active {
+            display: block;
+        }
+        /* Agent 卡片样式 */
+        .agent-card {
+            border-left: 4px solid #667eea;
+        }
+        .agent-card.default-agent {
+            border-left-color: #ffc107;
+        }
+        /* 渠道样式 */
+        .channel-web {
+            border-left: 4px solid #17a2b8;
+        }
+        .channel-matrix {
+            border-left: 4px solid #28a745;
+        }
+        /* Modal 表单样式 */
+        .modal-body .form-label {
+            font-weight: 600;
+            margin-top: 10px;
+        }
+        .thinking-config {
+            background: #f8f9fa;
+            padding: 15px;
+            border-radius: 8px;
+            margin-top: 10px;
+        }
+    </style>
+</head>
+<body>
+    <!-- 侧边栏 -->
+    <div class="sidebar">
+        <div class="logo">
+            <h4><i class="ri-robot-line"></i> AI对话系统</h4>
+            <div class="version">v2.0.0 后台管理</div>
+        </div>
+        <div class="nav mt-3">
+            <div class="nav-item active" data-page="llm-providers">
+                <i class="ri-cloud-line"></i> 大模型池
+            </div>
+            <div class="nav-item" data-page="agents">
+                <i class="ri-robot-2-line"></i> Agent管理
+            </div>
+            <div class="nav-item" data-page="channels">
+                <i class="ri-chat-3-line"></i> 渠道管理
+            </div>
+            <div class="nav-item" data-page="stats">
+                <i class="ri-bar-chart-box-line"></i> 统计数据
+            </div>
+            <div class="nav-item" data-page="config">
+                <i class="ri-settings-3-line"></i> 系统配置
+            </div>
+        </div>
+    </div>
+
+    <!-- 主内容 -->
+    <div class="main-content">
+        <!-- 大模型池管理 -->
+        <div class="page-section active" id="page-llm-providers">
+            <div class="page-header">
+                <h2><i class="ri-cloud-line"></i> 大模型池管理</h2>
+                <p class="text-muted">配置多个大模型API，供Agent选择使用</p>
+            </div>
+            <div class="card">
+                <div class="card-header d-flex justify-content-between">
+                    <span>大模型提供商列表</span>
+                    <button class="btn btn-primary btn-sm" onclick="showAddProviderModal()">
+                        <i class="ri-add-line"></i> 添加大模型
+                    </button>
+                </div>
+                <div class="card-body">
+                    <table class="table">
+                        <thead>
+                            <tr>
+                                <th>名称</th>
+                                <th>API地址</th>
+                                <th>默认模型</th>
+                                <th>思考支持</th>
+                                <th>状态</th>
+                                <th>操作</th>
+                            </tr>
+                        </thead>
+                        <tbody id="providers-list">
+                            <tr><td colspan="6" class="text-center">加载中...</td></tr>
+                        </tbody>
+                    </table>
+                </div>
+            </div>
+        </div>
+
+        <!-- Agent管理 -->
+        <div class="page-section" id="page-agents">
+            <div class="page-header">
+                <h2><i class="ri-robot-2-line"></i> Agent管理</h2>
+                <p class="text-muted">配置AI智能体，设定系统提示和思考功能</p>
+            </div>
+            <div class="card">
+                <div class="card-header d-flex justify-content-between">
+                    <span>Agent列表</span>
+                    <button class="btn btn-primary btn-sm" onclick="showAddAgentModal()">
+                        <i class="ri-add-line"></i> 添加Agent
+                    </button>
+                </div>
+                <div class="card-body">
+                    <table class="table">
+                        <thead>
+                            <tr>
+                                <th>名称</th>
+                                <th>显示名</th>
+                                <th>大模型池</th>
+                                <th>思考功能</th>
+                                <th>默认</th>
+                                <th>状态</th>
+                                <th>操作</th>
+                            </tr>
+                        </thead>
+                        <tbody id="agents-list">
+                            <tr><td colspan="7" class="text-center">加载中...</td></tr>
+                        </tbody>
+                    </table>
+                </div>
+            </div>
+        </div>
+
+        <!-- 渠道管理 -->
+        <div class="page-section" id="page-channels">
+            <div class="page-header">
+                <h2><i class="ri-chat-3-line"></i> 渠道管理</h2>
+                <p class="text-muted">管理网页端、Matrix等渠道，绑定Agent</p>
+            </div>
+            <div class="row">
+                <div class="col-md-6 mb-4">
+                    <div class="card channel-web">
+                        <div class="card-header">
+                            <i class="ri-global-line"></i> 网页端渠道
+                        </div>
+                        <div class="card-body" id="web-channel-info">
+                            加载中...
+                        </div>
+                    </div>
+                </div>
+                <div class="col-md-6 mb-4">
+                    <div class="card channel-matrix">
+                        <div class="card-header">
+                            <i class="ri-message-3-line"></i> Matrix渠道
+                        </div>
+                        <div class="card-body" id="matrix-channel-info">
+                            加载中...
+                        </div>
+                    </div>
+                </div>
+            </div>
+            <div class="card">
+                <div class="card-header">
+                    渠道-Agent绑定关系
+                </div>
+                <div class="card-body">
+                    <table class="table">
+                        <thead>
+                            <tr>
+                                <th>渠道</th>
+                                <th>绑定Agent</th>
+                                <th>优先级</th>
+                                <th>模式</th>
+                                <th>条件</th>
+                                <th>操作</th>
+                            </tr>
+                        </thead>
+                        <tbody id="mappings-list">
+                            <tr><td colspan="6" class="text-center">加载中...</td></tr>
+                        </tbody>
+                    </table>
+                </div>
+            </div>
+        </div>
+
+        <!-- 统计数据 -->
+        <div class="page-section" id="page-stats">
+            <div class="page-header">
+                <h2><i class="ri-bar-chart-box-line"></i> 统计数据</h2>
+            </div>
+            <div class="row">
+                <div class="col-md-3 mb-4">
+                    <div class="card">
+                        <div class="card-body text-center">
+                            <i class="ri-user-line" style="font-size: 40px; color: #667eea;"></i>
+                            <h3 id="stat-users" class="mt-2">-</h3>
+                            <p class="text-muted">用户数</p>
+                        </div>
+                    </div>
+                </div>
+                <div class="col-md-3 mb-4">
+                    <div class="card">
+                        <div class="card-body text-center">
+                            <i class="ri-chat-1-line" style="font-size: 40px; color: #28a745;"></i>
+                            <h3 id="stat-conversations" class="mt-2">-</h3>
+                            <p class="text-muted">对话数</p>
+                        </div>
+                    </div>
+                </div>
+                <div class="col-md-3 mb-4">
+                    <div class="card">
+                        <div class="card-body text-center">
+                            <i class="ri-message-2-line" style="font-size: 40px; color: #ffc107;"></i>
+                            <h3 id="stat-messages" class="mt-2">-</h3>
+                            <p class="text-muted">消息数</p>
+                        </div>
+                    </div>
+                </div>
+                <div class="col-md-3 mb-4">
+                    <div class="card">
+                        <div class="card-body text-center">
+                            <i class="ri-robot-line" style="font-size: 40px; color: #17a2b8;"></i>
+                            <h3 id="stat-agents" class="mt-2">-</h3>
+                            <p class="text-muted">Agent数</p>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+
+        <!-- 系统配置 -->
+        <div class="page-section" id="page-config">
+            <div class="page-header">
+                <h2><i class="ri-settings-3-line"></i> 系统配置</h2>
+            </div>
+            <div class="card">
+                <div class="card-body">
+                    <p class="text-muted">系统级别的通用配置...</p>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- 添加大模型Modal -->
+    <div class="modal fade" id="providerModal">
+        <div class="modal-dialog modal-lg">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h5 class="modal-title">添加/编辑大模型</h5>
+                    <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
+                </div>
+                <div class="modal-body">
+                    <form id="provider-form">
+                        <input type="hidden" id="provider-id">
+                        <div class="row">
+                            <div class="col-md-6">
+                                <label class="form-label">名称标识 *</label>
+                                <input type="text" class="form-control" id="provider-name" required placeholder="如: DeepSeek, 本地LLM">
+                            </div>
+                            <div class="col-md-6">
+                                <label class="form-label">默认模型</label>
+                                <input type="text" class="form-control" id="provider-default-model" placeholder="auto">
+                            </div>
+                        </div>
+                        <div class="row mt-3">
+                            <div class="col-md-12">
+                                <label class="form-label">API地址 *</label>
+                                <input type="text" class="form-control" id="provider-api-base" required placeholder="http://xxx:port/v1">
+                            </div>
+                        </div>
+                        <div class="row mt-3">
+                            <div class="col-md-12">
+                                <label class="form-label">API密钥</label>
+                                <input type="text" class="form-control" id="provider-api-key" placeholder="sk-xxx">
+                            </div>
+                        </div>
+                        <div class="row mt-3">
+                            <div class="col-md-4">
+                                <label class="form-label">Max Tokens</label>
+                                <input type="number" class="form-control" id="provider-max-tokens" value="4096">
+                            </div>
+                            <div class="col-md-4">
+                                <label class="form-label">Temperature</label>
+                                <input type="number" class="form-control" id="provider-temperature" value="0.7" step="0.1">
+                            </div>
+                            <div class="col-md-4">
+                                <label class="form-label">优先级</label>
+                                <input type="number" class="form-control" id="provider-priority" value="0">
+                            </div>
+                        </div>
+                        <div class="mt-3">
+                            <label class="form-label">描述</label>
+                            <textarea class="form-control" id="provider-description" rows="2"></textarea>
+                        </div>
+                        <div class="mt-3 form-check">
+                            <input type="checkbox" class="form-check-input" id="provider-active" checked>
+                            <label class="form-check-label">启用</label>
+                        </div>
+                        <hr>
+                        <h6>思考功能配置</h6>
+                        <div class="thinking-config">
+                            <div class="row">
+                                <div class="col-md-6 form-check">
+                                    <input type="checkbox" class="form-check-input" id="provider-supports-thinking">
+                                    <label class="form-check-label">支持原生思考功能</label>
+                                </div>
+                                <div class="col-md-6">
+                                    <label class="form-label">思考模式模型名</label>
+                                    <input type="text" class="form-control" id="provider-thinking-model" placeholder="如果有单独的思考模型">
+                                </div>
+                            </div>
+                        </div>
+                        <div class="mt-3">
+                            <button type="button" class="btn btn-outline-primary" onclick="fetchProviderModels()">
+                                <i class="ri-refresh-line"></i> 从API获取模型列表
+                            </button>
+                            <button type="button" class="btn btn-outline-secondary" onclick="testProviderConnection()">
+                                <i class="ri-link"></i> 测试连接
+                            </button>
+                        </div>
+                        <div class="mt-2" id="provider-models-preview"></div>
+                        <div class="mt-2" id="provider-test-result"></div>
+                    </form>
+                </div>
+                <div class="modal-footer">
+                    <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">取消</button>
+                    <button type="button" class="btn btn-primary" onclick="saveProvider()">保存</button>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- 添加AgentModal -->
+    <div class="modal fade" id="agentModal">
+        <div class="modal-dialog modal-lg">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h5 class="modal-title">添加/编辑Agent</h5>
+                    <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
+                </div>
+                <div class="modal-body">
+                    <form id="agent-form">
+                        <input type="hidden" id="agent-id">
+                        <div class="row">
+                            <div class="col-md-4">
+                                <label class="form-label">名称标识 *</label>
+                                <input type="text" class="form-control" id="agent-name" required placeholder="如: assistant, coder">
+                            </div>
+                            <div class="col-md-4">
+                                <label class="form-label">显示名称</label>
+                                <input type="text" class="form-control" id="agent-display-name" placeholder="默认助手">
+                            </div>
+                            <div class="col-md-4">
+                                <label class="form-label">大模型池 *</label>
+                                <select class="form-select" id="agent-llm-provider" required>
+                                    <option value="">请选择...</option>
+                                </select>
+                            </div>
+                        </div>
+                        <div class="row mt-3">
+                            <div class="col-md-6">
+                                <label class="form-label">模型覆盖</label>
+                                <input type="text" class="form-control" id="agent-model-override" placeholder="覆盖Provider默认模型">
+                            </div>
+                            <div class="col-md-6">
+                                <label class="form-label">最大历史数</label>
+                                <input type="number" class="form-control" id="agent-max-history" value="20">
+                            </div>
+                        </div>
+                        <div class="mt-3">
+                            <label class="form-label">系统设定（System Prompt）</label>
+                            <textarea class="form-control" id="agent-system-prompt" rows="4">你是一个有用的AI助手。</textarea>
+                        </div>
+                        <div class="mt-3">
+                            <label class="form-label">描述</label>
+                            <textarea class="form-control" id="agent-description" rows="2"></textarea>
+                        </div>
+                        <div class="row mt-3">
+                            <div class="col-md-4 form-check">
+                                <input type="checkbox" class="form-check-input" id="agent-active" checked>
+                                <label class="form-check-label">启用</label>
+                            </div>
+                            <div class="col-md-4 form-check">
+                                <input type="checkbox" class="form-check-input" id="agent-default">
+                                <label class="form-check-label">设为默认</label>
+                            </div>
+                            <div class="col-md-4">
+                                <label class="form-label">温度覆盖</label>
+                                <input type="number" class="form-control" id="agent-temperature-override" step="0.1" placeholder="可选">
+                            </div>
+                        </div>
+                        <hr>
+                        <h6>思考功能配置</h6>
+                        <div class="thinking-config">
+                            <div class="form-check mb-2">
+                                <input type="checkbox" class="form-check-input" id="agent-enable-thinking" checked>
+                                <label class="form-check-label">启用思考功能</label>
+                            </div>
+                            <div class="mt-2">
+                                <label class="form-label">思考提示词</label>
+                                <textarea class="form-control" id="agent-thinking-prompt" rows="2" placeholder="请先仔细思考这个问题..."></textarea>
+                            </div>
+                            <div class="row mt-2">
+                                <div class="col-md-6">
+                                    <label class="form-label">思考前缀标识</label>
+                                    <input type="text" class="form-control" id="agent-thinking-prefix" placeholder="如: ">
+                                </div>
+                                <div class="col-md-6">
+                                    <label class="form-label">思考后缀标识</label>
+                                    <input type="text" class="form-control" id="agent-thinking-suffix" placeholder="如: ">
+                                </div>
+                            </div>
+                        </div>
+                    </form>
+                </div>
+                <div class="modal-footer">
+                    <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">取消</button>
+                    <button type="button" class="btn btn-primary" onclick="saveAgent()">保存</button>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- 绑定AgentModal -->
+    <div class="modal fade" id="bindingModal">
+        <div class="modal-dialog">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h5 class="modal-title">绑定Agent到渠道</h5>
+                    <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
+                </div>
+                <div class="modal-body">
+                    <form id="binding-form">
+                        <input type="hidden" id="binding-channel-id">
+                        <div class="mb-3">
+                            <label class="form-label">选择Agent</label>
+                            <select class="form-select" id="binding-agent-id" required>
+                                <option value="">请选择...</option>
+                            </select>
+                        </div>
+                        <div class="mb-3">
+                            <label class="form-label">优先级</label>
+                            <input type="number" class="form-control" id="binding-priority" value="0">
+                            <small class="text-muted">数字越小优先级越高</small>
+                        </div>
+                        <div class="mb-3">
+                            <label class="form-label">模式</label>
+                            <select class="form-select" id="binding-mode">
+                                <option value="single">single - 单Agent</option>
+                                <option value="round_robin">round_robin - 轮询</option>
+                                <option value="fallback">fallback - 备用</option>
+                            </select>
+                        </div>
+                        <div class="mb-3">
+                            <label class="form-label">条件（JSON）</label>
+                            <textarea class="form-control" id="binding-conditions" rows="2" placeholder='{"user_level": "vip"}'></textarea>
+                            <small class="text-muted">可选，满足条件时才使用此Agent</small>
+                        </div>
+                    </form>
+                </div>
+                <div class="modal-footer">
+                    <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">取消</button>
+                    <button type="button" class="btn btn-primary" onclick="saveBinding()">保存</button>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- 编辑Matrix配置Modal -->
+    <div class="modal fade" id="matrixConfigModal">
+        <div class="modal-dialog">
+            <div class="modal-content">
+                <div class="modal-header">
+                    <h5 class="modal-title">Matrix配置</h5>
+                    <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
+                </div>
+                <div class="modal-body">
+                    <form id="matrix-config-form">
+                        <div class="mb-3">
+                            <label class="form-label">服务器地址</label>
+                            <input type="text" class="form-control" id="matrix-homeserver" placeholder="http://matrix.tphai.com">
+                        </div>
+                        <div class="mb-3">
+                            <label class="form-label">Bot用户名</label>
+                            <input type="text" class="form-control" id="matrix-username" placeholder="@ai-bot:matrix.tphai.com">
+                        </div>
+                        <div class="mb-3">
+                            <label class="form-label">密码</label>
+                            <input type="text" class="form-control" id="matrix-password">
+                        </div>
+                    </form>
+                </div>
+                <div class="modal-footer">
+                    <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">取消</button>
+                    <button type="button" class="btn btn-primary" onclick="saveMatrixConfig()">保存</button>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/js/bootstrap.bundle.min.js"></script>
+    <script>
+        // 页面切换
+        document.querySelectorAll('.sidebar .nav-item').forEach(item => {
+            item.addEventListener('click', () => {
+                // 更新导航状态
+                document.querySelectorAll('.sidebar .nav-item').forEach(i => i.classList.remove('active'));
+                item.classList.add('active');
+                
+                // 切换页面
+                const page = item.dataset.page;
+                document.querySelectorAll('.page-section').forEach(s => s.classList.remove('active'));
+                document.getElementById('page-' + page).classList.add('active');
+                
+                // 加载数据
+                loadPageData(page);
+            });
+        });
+
+        function loadPageData(page) {
+            if (page === 'llm-providers') loadProviders();
+            if (page === 'agents') loadAgents();
+            if (page === 'channels') loadChannels();
+            if (page === 'stats') loadStats();
+        }
+
+        // 初始加载
+        loadProviders();
+        loadStats();
+
+        // ===== 大模型池 =====
+        let providersData = [];
+        
+        async function loadProviders() {
+            const res = await fetch('/api/v2/providers');
+            const data = await res.json();
+            providersData = data.providers || [];
+            
+            const tbody = document.getElementById('providers-list');
+            if (providersData.length === 0) {
+                tbody.innerHTML = '<tr><td colspan="6" class="text-center text-muted">暂无数据</td></tr>';
+                return;
+            }
+            
+            tbody.innerHTML = providersData.map(p => `
+                <tr>
+                    <td><strong>${p.name}</strong></td>
+                    <td><small>${p.api_base || '-'}</small></td>
+                    <td>${p.default_model || 'auto'}</td>
+                    <td>
+                        ${p.supports_thinking ? '<span class="badge bg-success">支持</span>' : '<span class="badge bg-secondary">不支持</span>}
+                        ${p.thinking_model ? `<small class="text-muted">(${p.thinking_model})</small>` : ''}
+                    </td>
+                    <td>${p.is_active ? '<span class="badge badge-active">启用</span>' : '<span class="badge badge-inactive">禁用</span>'}</td>
+                    <td>
+                        <button class="btn btn-sm btn-outline-primary" onclick="editProvider(${p.id})">
+                            <i class="ri-edit-line"></i>
+                        </button>
+                        <button class="btn btn-sm btn-outline-danger" onclick="deleteProvider(${p.id}, '${p.name}')">
+                            <i class="ri-delete-bin-line"></i>
+                        </button>
+                    </td>
+                </tr>
+            `).join('');
+            
+            // 更新Agent选择框
+            updateProviderSelect();
+        }
+
+        function updateProviderSelect() {
+            const select = document.getElementById('agent-llm-provider');
+            select.innerHTML = '<option value="">请选择...</option>' + 
+                providersData.filter(p => p.is_active).map(p => 
+                    `<option value="${p.id}">${p.name} (${p.default_model || 'auto'})</option>`
+                ).join('');
+        }
+
+        function showAddProviderModal() {
+            document.getElementById('provider-form').reset();
+            document.getElementById('provider-id').value = '';
+            document.getElementById('provider-active').checked = true;
+            document.getElementById('provider-models-preview').innerHTML = '';
+            document.getElementById('provider-test-result').innerHTML = '';
+            new bootstrap.Modal(document.getElementById('providerModal')).show();
+        }
+
+        function editProvider(id) {
+            const p = providersData.find(x => x.id === id);
+            if (!p) return;
+            
+            document.getElementById('provider-id').value = id;
+            document.getElementById('provider-name').value = p.name;
+            document.getElementById('provider-api-base').value = p.api_base || '';
+            document.getElementById('provider-api-key').value = p.api_key || '';
+            document.getElementById('provider-default-model').value = p.default_model || '';
+            document.getElementById('provider-max-tokens').value = p.max_tokens || 4096;
+            document.getElementById('provider-temperature').value = p.temperature || 0.7;
+            document.getElementById('provider-priority').value = p.priority || 0;
+            document.getElementById('provider-description').value = p.description || '';
+            document.getElementById('provider-active').checked = p.is_active;
+            document.getElementById('provider-supports-thinking').checked = p.supports_thinking;
+            document.getElementById('provider-thinking-model').value = p.thinking_model || '';
+            
+            new bootstrap.Modal(document.getElementById('providerModal')).show();
+        }
+
+        async function saveProvider() {
+            const id = document.getElementById('provider-id').value;
+            const data = {
+                name: document.getElementById('provider-name').value,
+                api_base: document.getElementById('provider-api-base').value,
+                api_key: document.getElementById('provider-api-key').value,
+                default_model: document.getElementById('provider-default-model').value || 'auto',
+                max_tokens: parseInt(document.getElementById('provider-max-tokens').value) || 4096,
+                temperature: parseFloat(document.getElementById('provider-temperature').value) || 0.7,
+                priority: parseInt(document.getElementById('provider-priority').value) || 0,
+                description: document.getElementById('provider-description').value,
+                is_active: document.getElementById('provider-active').checked,
+                supports_thinking: document.getElementById('provider-supports-thinking').checked,
+                thinking_model: document.getElementById('provider-thinking-model').value
+            };
+            
+            const url = id ? `/api/v2/providers/${id}` : '/api/v2/providers';
+            const method = id ? 'PUT' : 'POST';
+            
+            const res = await fetch(url, {
+                method: method,
+                headers: {'Content-Type': 'application/json'},
+                body: JSON.stringify(data)
+            });
+            
+            const result = await res.json();
+            if (result.success) {
+                bootstrap.Modal.getInstance(document.getElementById('providerModal')).hide();
+                loadProviders();
+                alert('保存成功');
+            } else {
+                alert('保存失败: ' + result.message);
+            }
+        }
+
+        async function deleteProvider(id, name) {
+            if (!confirm(`确定删除大模型 "${name}"？\n注意：如果有Agent使用此模型，删除将失败。`)) return;
+            
+            const res = await fetch(`/api/v2/providers/${id}`, {method: 'DELETE'});
+            const result = await res.json();
+            
+            if (result.success) {
+                loadProviders();
+                alert('删除成功');
+            } else {
+                alert('删除失败: ' + result.message);
+            }
+        }
+
+        async function fetchProviderModels() {
+            const api_base = document.getElementById('provider-api-base').value;
+            const api_key = document.getElementById('provider-api-key').value;
+            
+            if (!api_base) {
+                alert('请先填写API地址');
+                return;
+            }
+            
+            document.getElementById('provider-models-preview').innerHTML = '正在获取...';
+            
+            const res = await fetch('/api/v2/providers/models', {
+                method: 'POST',
+                headers: {'Content-Type': 'application/json'},
+                body: JSON.stringify({api_base, api_key})
+            });
+            
+            const result = await res.json();
+            if (result.models && result.models.length > 0) {
+                document.getElementById('provider-models-preview').innerHTML = 
+                    '<strong>可用模型:</strong> ' + result.models.map(m => `<span class="badge bg-secondary">${m.id}</span>`).join(' ');
+            } else {
+                document.getElementById('provider-models-preview').innerHTML = 
+                    '<span class="text-warning">无法获取模型列表</span>';
+            }
+        }
+
+        async function testProviderConnection() {
+            const api_base = document.getElementById('provider-api-base').value;
+            const api_key = document.getElementById('provider-api-key').value;
+            const model = document.getElementById('provider-default-model').value || 'auto';
+            
+            if (!api_base) {
+                alert('请先填写API地址');
+                return;
+            }
+            
+            document.getElementById('provider-test-result').innerHTML = '正在测试...';
+            
+            const res = await fetch('/api/v2/providers/test', {
+                method: 'POST',
+                headers: {'Content-Type': 'application/json'},
+                body: JSON.stringify({api_base, api_key, model})
+            });
+            
+            const result = await res.json();
+            if (result.success) {
+                document.getElementById('provider-test-result').innerHTML = 
+                    '<span class="text-success"><i class="ri-check-line"></i> ' + result.message + '</span>';
+            } else {
+                document.getElementById('provider-test-result').innerHTML = 
+                    '<span class="text-danger"><i class="ri-close-line"></i> ' + result.message + '</span>';
+            }
+        }
+
+        // ===== Agent =====
+        let agentsData = [];
+        
+        async function loadAgents() {
+            const res = await fetch('/api/v2/agents');
+            const data = await res.json();
+            agentsData = data.agents || [];
+            
+            const tbody = document.getElementById('agents-list');
+            if (agentsData.length === 0) {
+                tbody.innerHTML = '<tr><td colspan="7" class="text-center text-muted">暂无数据</td></tr>';
+                return;
+            }
+            
+            tbody.innerHTML = agentsData.map(a => `
+                <tr class="${a.is_default ? 'default-agent' : ''}">
+                    <td><strong>${a.name}</strong></td>
+                    <td>${a.display_name || a.name}</td>
+                    <td>${a.llm_provider_name || '-'}</td>
+                    <td>
+                        ${a.enable_thinking ? '<span class="badge bg-success">开启</span>' : '<span class="badge bg-secondary">关闭</span>'}
+                    </td>
+                    <td>${a.is_default ? '<span class="badge badge-default">默认</span>' : '-'}</td>
+                    <td>${a.is_active ? '<span class="badge badge-active">启用</span>' : '<span class="badge badge-inactive">禁用</span>'}</td>
+                    <td>
+                        <button class="btn btn-sm btn-outline-primary" onclick="editAgent(${a.id})">
+                            <i class="ri-edit-line"></i>
+                        </button>
+                        ${!a.is_default ? `<button class="btn btn-sm btn-outline-warning" onclick="setDefaultAgent(${a.id})">
+                            <i class="ri-star-line"></i>
+                        </button>` : ''}
+                        ${!a.is_default ? `<button class="btn btn-sm btn-outline-danger" onclick="deleteAgent(${a.id}, '${a.name}')">
+                            <i class="ri-delete-bin-line"></i>
+                        </button>` : ''}
+                    </td>
+                </tr>
+            `).join('');
+            
+            // 更新绑定选择框
+            updateAgentSelect();
+        }
+
+        function updateAgentSelect() {
+            const select = document.getElementById('binding-agent-id');
+            select.innerHTML = '<option value="">请选择...</option>' + 
+                agentsData.filter(a => a.is_active).map(a => 
+                    `<option value="${a.id}">${a.display_name || a.name}</option>`
+                ).join('');
+        }
+
+        function showAddAgentModal() {
+            document.getElementById('agent-form').reset();
+            document.getElementById('agent-id').value = '';
+            document.getElementById('agent-active').checked = true;
+            document.getElementById('agent-enable-thinking').checked = true;
+            document.getElementById('agent-system-prompt').value = '你是一个有用的AI助手。';
+            updateProviderSelect();
+            new bootstrap.Modal(document.getElementById('agentModal')).show();
+        }
+
+        function editAgent(id) {
+            const a = agentsData.find(x => x.id === id);
+            if (!a) return;
+            
+            updateProviderSelect();
+            
+            document.getElementById('agent-id').value = id;
+            document.getElementById('agent-name').value = a.name;
+            document.getElementById('agent-display-name').value = a.display_name || '';
+            document.getElementById('agent-llm-provider').value = a.llm_provider_id;
+            document.getElementById('agent-model-override').value = a.model_override || '';
+            document.getElementById('agent-max-history').value = a.max_history || 20;
+            document.getElementById('agent-system-prompt').value = a.system_prompt || '';
+            document.getElementById('agent-description').value = a.description || '';
+            document.getElementById('agent-active').checked = a.is_active;
+            document.getElementById('agent-default').checked = a.is_default;
+            document.getElementById('agent-temperature-override').value = a.temperature_override || '';
+            document.getElementById('agent-enable-thinking').checked = a.enable_thinking;
+            document.getElementById('agent-thinking-prompt').value = a.thinking_prompt || '';
+            document.getElementById('agent-thinking-prefix').value = a.thinking_prefix || '';
+            document.getElementById('agent-thinking-suffix').value = a.thinking_suffix || '';
+            
+            new bootstrap.Modal(document.getElementById('agentModal')).show();
+        }
+
+        async function saveAgent() {
+            const id = document.getElementById('agent-id').value;
+            const data = {
+                name: document.getElementById('agent-name').value,
+                display_name: document.getElementById('agent-display-name').value,
+                llm_provider_id: parseInt(document.getElementById('agent-llm-provider').value),
+                model_override: document.getElementById('agent-model-override').value,
+                max_history: parseInt(document.getElementById('agent-max-history').value) || 20,
+                system_prompt: document.getElementById('agent-system-prompt').value,
+                description: document.getElementById('agent-description').value,
+                is_active: document.getElementById('agent-active').checked,
+                is_default: document.getElementById('agent-default').checked,
+                temperature_override: parseFloat(document.getElementById('agent-temperature-override').value) || null,
+                enable_thinking: document.getElementById('agent-enable-thinking').checked,
+                thinking_prompt: document.getElementById('agent-thinking-prompt').value,
+                thinking_prefix: document.getElementById('agent-thinking-prefix').value,
+                thinking_suffix: document.getElementById('agent-thinking-suffix').value
+            };
+            
+            const url = id ? `/api/v2/agents/${id}` : '/api/v2/agents';
+            const method = id ? 'PUT' : 'POST';
+            
+            const res = await fetch(url, {
+                method: method,
+                headers: {'Content-Type': 'application/json'},
+                body: JSON.stringify(data)
+            });
+            
+            const result = await res.json();
+            if (result.success) {
+                bootstrap.Modal.getInstance(document.getElementById('agentModal')).hide();
+                loadAgents();
+                alert('保存成功');
+            } else {
+                alert('保存失败: ' + result.message);
+            }
+        }
+
+        async function setDefaultAgent(id) {
+            const res = await fetch(`/api/v2/agents/${id}/default`, {method: 'POST'});
+            const result = await res.json();
+            if (result.success) {
+                loadAgents();
+                alert('已设为默认Agent');
+            }
+        }
+
+        async function deleteAgent(id, name) {
+            if (!confirm(`确定删除Agent "${name}"？`)) return;
+            
+            const res = await fetch(`/api/v2/agents/${id}`, {method: 'DELETE'});
+            const result = await res.json();
+            
+            if (result.success) {
+                loadAgents();
+                alert('删除成功');
+            } else {
+                alert('删除失败: ' + result.message);
+            }
+        }
+
+        // ===== 渠道 =====
+        let channelsData = [];
+        let mappingsData = [];
+        
+        async function loadChannels() {
+            const res = await fetch('/api/v2/channels');
+            const data = await res.json();
+            channelsData = data.channels || [];
+            mappingsData = data.mappings || [];
+            
+            // 显示渠道信息
+            const webChannel = channelsData.find(c => c.channel_type === 'web');
+            const matrixChannel = channelsData.find(c => c.channel_type === 'matrix');
+            
+            document.getElementById('web-channel-info').innerHTML = renderChannelInfo(webChannel, 'web');
+            document.getElementById('matrix-channel-info').innerHTML = renderChannelInfo(matrixChannel, 'matrix');
+            
+            // 显示绑定关系
+            const tbody = document.getElementById('mappings-list');
+            if (mappingsData.length === 0) {
+                tbody.innerHTML = '<tr><td colspan="6" class="text-center text-muted">暂无绑定</td></tr>';
+                return;
+            }
+            
+            tbody.innerHTML = mappingsData.map(m => `
+                <tr>
+                    <td><span class="badge bg-${m.channel_type === 'web' ? 'info' : 'success'}">${m.channel_name}</span></td>
+                    <td>${m.agent_name}</td>
+                    <td>${m.priority}</td>
+                    <td><span class="badge bg-secondary">${m.mode}</span></td>
+                    <td>${m.conditions ? JSON.stringify(m.conditions) : '-'}</td>
+                    <td>
+                        <button class="btn btn-sm btn-outline-danger" onclick="deleteMapping(${m.id})">
+                            <i class="ri-delete-bin-line"></i>
+                        </button>
+                    </td>
+                </tr>
+            `).join('');
+        }
+
+        function renderChannelInfo(channel, type) {
+            if (!channel) {
+                return `<p class="text-muted">未配置</p>
+                        <button class="btn btn-sm btn-primary" onclick="createChannel('${type}')">创建渠道</button>`;
+            }
+            
+            const agentsHtml = channel.agent_mappings && channel.agent_mappings.length > 0
+                ? channel.agent_mappings.map(m => `<span class="badge bg-secondary">${m.agent.display_name}</span>`).join(' ')
+                : '<span class="text-muted">未绑定Agent</span>';
+            
+            const configBtn = type === 'matrix' 
+                ? `<button class="btn btn-sm btn-outline-primary mt-2" onclick="editMatrixConfig(${channel.id})">
+                       <i class="ri-settings-3-line"></i> 配置Matrix
+                   </button>`
+                : '';
+            
+            return `
+                <p><strong>名称:</strong> ${channel.name}</p>
+                <p><strong>状态:</strong> ${channel.is_active ? '<span class="badge bg-success">启用</span>' : '<span class="badge bg-secondary">禁用</span>'}</p>
+                <p><strong>绑定Agent:</strong> ${agentsHtml}</p>
+                <button class="btn btn-sm btn-primary" onclick="showBindAgentModal(${channel.id})">绑定Agent</button>
+                ${configBtn}
+            `;
+        }
+
+        function showBindAgentModal(channelId) {
+            document.getElementById('binding-channel-id').value = channelId;
+            document.getElementById('binding-form').reset();
+            updateAgentSelect();
+            new bootstrap.Modal(document.getElementById('bindingModal')).show();
+        }
+
+        async function saveBinding() {
+            const channelId = document.getElementById('binding-channel-id').value;
+            const conditionsStr = document.getElementById('binding-conditions').value;
+            
+            const data = {
+                channel_id: parseInt(channelId),
+                agent_id: parseInt(document.getElementById('binding-agent-id').value),
+                priority: parseInt(document.getElementById('binding-priority').value) || 0,
+                mode: document.getElementById('binding-mode').value,
+                conditions: conditionsStr ? JSON.parse(conditionsStr) : null
+            };
+            
+            const res = await fetch('/api/v2/channels/bind', {
+                method: 'POST',
+                headers: {'Content-Type': 'application/json'},
+                body: JSON.stringify(data)
+            });
+            
+            const result = await res.json();
+            if (result.success) {
+                bootstrap.Modal.getInstance(document.getElementById('bindingModal')).hide();
+                loadChannels();
+                alert('绑定成功');
+            } else {
+                alert('绑定失败: ' + result.message);
+            }
+        }
+
+        async function deleteMapping(id) {
+            if (!confirm('确定解绑此Agent？')) return;
+            
+            const res = await fetch(`/api/v2/channels/unbind/${id}`, {method: 'DELETE'});
+            const result = await res.json();
+            
+            if (result.success) {
+                loadChannels();
+                alert('解绑成功');
+            }
+        }
+
+        function editMatrixConfig(channelId) {
+            const channel = channelsData.find(c => c.id === channelId);
+            if (!channel) return;
+            
+            const config = channel.config || {};
+            document.getElementById('matrix-homeserver').value = config.homeserver || '';
+            document.getElementById('matrix-username').value = config.username || '';
+            document.getElementById('matrix-password').value = config.password || '';
+            
+            // 保存channel ID用于更新
+            document.getElementById('matrix-config-form').dataset.channelId = channelId;
+            
+            new bootstrap.Modal(document.getElementById('matrixConfigModal')).show();
+        }
+
+        async function saveMatrixConfig() {
+            const channelId = document.getElementById('matrix-config-form').dataset.channelId;
+            
+            const res = await fetch(`/api/v2/channels/${channelId}/config`, {
+                method: 'PUT',
+                headers: {'Content-Type': 'application/json'},
+                body: JSON.stringify({
+                    config: {
+                        homeserver: document.getElementById('matrix-homeserver').value,
+                        username: document.getElementById('matrix-username').value,
+                        password: document.getElementById('matrix-password').value
+                    }
+                })
+            });
+            
+            const result = await res.json();
+            if (result.success) {
+                bootstrap.Modal.getInstance(document.getElementById('matrixConfigModal')).hide();
+                loadChannels();
+                alert('Matrix配置已更新');
+            }
+        }
+
+        // ===== 统计 =====
+        async function loadStats() {
+            const res = await fetch('/api/admin/stats');
+            const data = await res.json();
+            
+            document.getElementById('stat-users').textContent = data.total_users || 0;
+            document.getElementById('stat-conversations').textContent = data.total_conversations || 0;
+            document.getElementById('stat-messages').textContent = data.total_messages || 0;
+            
+            // Agent数量
+            const agentsRes = await fetch('/api/v2/agents');
+            const agentsData = await agentsRes.json();
+            document.getElementById('stat-agents').textContent = (agentsData.agents || []).length;
+        }
+    </script>
+</body>
+</html>
\ No newline at end of file