diff --git a/core/fay_core.py b/core/fay_core.py
index 2f603cc..aa693bd 100644
--- a/core/fay_core.py
+++ b/core/fay_core.py
@@ -323,7 +323,7 @@ class FeiFei:
                 return result         
                 
         except BaseException as e:
-            print(e) #TODO 不合成声音时，这里打印了1，调试了一下
+            print(e) 
         return None
     
     #下载wav
diff --git a/core/recorder.py b/core/recorder.py
index e04eef0..fb3210d 100644
--- a/core/recorder.py
+++ b/core/recorder.py
@@ -17,6 +17,7 @@ import tempfile
 import wave
 from core import fay_core
 from core import interact
+from core import stream_manager
 # 麦克风启动时间 (秒)
 _ATTACK = 0.1
 
@@ -135,6 +136,7 @@ class Recorder:
 
                             intt = interact.Interact("auto_play", 2, {'user': self.username, 'text': "在呢，你说？" , "isfirst" : True, "isend" : True})
                             self.__fay.on_interact(intt)
+                            stream_manager.new_instance().clear_Stream_with_audio(self.username)
                             self.processing = False
                             self.timer.cancel()  # 取消之前的计时器任务
                             
@@ -169,9 +171,8 @@ class Recorder:
                         if wsa_server.get_instance().is_connected(self.username):
                             content = {'Topic': 'human', 'Data': {'Key': 'log', 'Value': "唤醒成功！"}, 'Username' : self.username, 'robot': f'{cfg.fay_url}/robot/Listening.jpg'}
                             wsa_server.get_instance().add_cmd(content)
-                        #去除唤醒词后语句
-                        question = text#[len(wake_up_word):].lstrip()
-                        self.__fay.sound_query = Queue()
+                        question = text#[len(wake_up_word):].lstrip()不去除唤醒词
+                        stream_manager.new_instance().clear_Stream_with_audio(self.username)
                         time.sleep(0.3)
                         self.on_speaking(question)
                         self.processing = False
diff --git a/core/stream_manager.py b/core/stream_manager.py
index e29ea2f..8aefab5 100644
--- a/core/stream_manager.py
+++ b/core/stream_manager.py
@@ -78,11 +78,14 @@ class StreamManager:
         if len(sentence) > 10240:  # 10KB限制
             sentence = sentence[:10240]
 
-        if sentence.endswith('_<isfirst>'):
-            self.clear_Stream(username)
-
         # 使用锁保护获取和写入操作
         with self.lock:
+            # 检查是否包含_<isfirst>标记（可能在句子中间）
+            if '_<isfirst>' in sentence:
+                # 清空文本流
+                self._clear_Stream_internal(username)
+                # 清空音频队列（打断时需要清空音频）
+                self._clear_audio_queue(username)
             try:
                 Stream, nlp_Stream = self.get_Stream(username)
                 success = Stream.write(sentence)
@@ -92,16 +95,41 @@ class StreamManager:
                 print(f"写入句子时出错: {e}")
                 return False
 
+    def _clear_Stream_internal(self, username):
+        """
+        内部清除文本流方法，不获取锁（调用者必须已持有锁）
+        :param username: 用户名
+        """
+        if username in self.streams:
+            self.streams[username].clear()
+        if username in self.nlp_streams:
+            self.nlp_streams[username].clear()
+
+    def _clear_audio_queue(self, username):
+        """
+        清空指定用户的音频队列
+        :param username: 用户名
+        """
+        import queue
+        fay_core = fay_booter.feiFei
+        fay_core.sound_query = queue.Queue()
+
     def clear_Stream(self, username):
         """
-        清除指定用户ID的文本流数据
+        清除指定用户ID的文本流数据（外部调用接口，仅清除文本流）
         :param username: 用户名
         """
         with self.lock:
-            if username in self.streams:
-                self.streams[username].clear()
-            if username in self.nlp_streams:
-                self.nlp_streams[username].clear()
+            self._clear_Stream_internal(username)
+
+    def clear_Stream_with_audio(self, username):
+        """
+        清除指定用户ID的文本流数据和音频队列（完全清除）
+        :param username: 用户名
+        """
+        with self.lock:
+            self._clear_Stream_internal(username)
+            self._clear_audio_queue(username)
 
     def listen(self, username, stream, nlp_stream):
         while self.running:
diff --git a/fay_booter.py b/fay_booter.py
index d22cd57..0f413f3 100644
--- a/fay_booter.py
+++ b/fay_booter.py
@@ -291,6 +291,15 @@ def stop():
     util.log(1, '正在关闭服务...')
     __running = False
     
+    # 断开所有MCP服务连接
+    util.log(1, '正在断开所有MCP服务连接...')
+    try:
+        from faymcp import mcp_service
+        mcp_service.disconnect_all_mcp_servers()
+        util.log(1, '所有MCP服务连接已断开')
+    except Exception as e:
+        util.log(1, f'断开MCP服务连接失败: {str(e)}')
+    
     # 保存代理记忆
     util.log(1, '正在保存代理记忆...')
     try:
diff --git a/faymcp/data/mcp_servers.json b/faymcp/data/mcp_servers.json
index ecd1f7f..9026546 100644
--- a/faymcp/data/mcp_servers.json
+++ b/faymcp/data/mcp_servers.json
@@ -1,9 +1,30 @@
 [
     {
         "id": 1,
-        "name": "time",
-        "ip": "https://mcp.api-inference.modelscope.cn/sse/896ded03280143",
-        "connection_time": "2025-05-17 01:11:25",
-        "key": ""
+        "name": "tools",
+        "ip": "",
+        "connection_time": "2025-08-28 00:17:54",
+        "key": "",
+        "transport": "stdio",
+        "command": "python",
+        "args": [
+            "test/mcp_stdio_example.py"
+        ],
+        "cwd": "",
+        "env": {}
+    },
+    {
+        "id": 2,
+        "name": "Fay日程管理",
+        "ip": "",
+        "connection_time": "2025-08-28 00:17:57",
+        "key": "",
+        "transport": "stdio",
+        "command": "python",
+        "args": [
+            "server.py"
+        ],
+        "cwd": "mcp_servers/schedule_manager",
+        "env": {}
     }
 ]
\ No newline at end of file
diff --git a/faymcp/data/mcp_tool_states.json b/faymcp/data/mcp_tool_states.json
new file mode 100644
index 0000000..35cbae2
--- /dev/null
+++ b/faymcp/data/mcp_tool_states.json
@@ -0,0 +1,16 @@
+{
+    "5": {
+        "now": true,
+        "add": false,
+        "upper": false,
+        "echo": false,
+        "ping": false
+    },
+    "1": {
+        "add": false,
+        "upper": false,
+        "echo": false,
+        "ping": false
+    },
+    "2": {}
+}
\ No newline at end of file
diff --git a/faymcp/mcp_client.py b/faymcp/mcp_client.py
index f4d4a0a..bc365f1 100644
--- a/faymcp/mcp_client.py
+++ b/faymcp/mcp_client.py
@@ -4,11 +4,24 @@
 import asyncio
 import logging
 import time
+import os
+import sys
+import threading
 from contextlib import AsyncExitStack
+from typing import Optional, Dict, Any
 from mcp import ClientSession
 from mcp.client.sse import sse_client
 from utils import util
 
+# 尝试导入本地 stdio 传输
+try:
+    from mcp.client.stdio import stdio_client, StdioServerParameters
+    HAS_STDIO = True
+except Exception:
+    stdio_client = None
+    StdioServerParameters = None
+    HAS_STDIO = False
+
 # 设置日志记录
 logging.basicConfig(level=logging.ERROR)
 logger = logging.getLogger(__name__)
@@ -16,101 +29,166 @@ logger = logging.getLogger(__name__)
 class McpClient:
     """
     MCP客户端类，用于连接MCP服务器并调用其工具
+    支持两种传输:
+    - SSE: 远程HTTP(S) SSE服务器
+    - STDIO: 本地进程通过stdin/stdout通信
     """
-    def __init__(self, server_url, api_key=None):
+    def __init__(self, server_url: Optional[str] = None, api_key: Optional[str] = None,
+                 transport: str = "sse", stdio_config: Optional[Dict[str, Any]] = None):
         """
         初始化MCP客户端
-        :param server_url: MCP服务器URL
-        :param api_key: MCP服务器API密钥（可选）
+        :param server_url: MCP服务器URL（SSE模式必填）
+        :param api_key: MCP服务器API密钥（可选，仅SSE）
+        :param transport: 传输类型: 'sse' 或 'stdio'
+        :param stdio_config: 本地stdio配置，如 {command, args, env, cwd}
         """
         self.server_url = server_url
         self.api_key = api_key
+        self.transport = transport or "sse"
+        # 如果未显式指定，按server_url推断
+        if self.transport not in ("sse", "stdio"):
+            self.transport = "stdio" if (server_url and str(server_url).startswith("stdio:")) else "sse"
+        self.stdio_config = stdio_config or {}
         self.session = None
         self.tools = None
         self.connected = False
         self.event_loop = None
+        self.exit_stack: Optional[AsyncExitStack] = None
+        # 超时配置（秒）
+        self.init_timeout_seconds = 20
+        self.list_timeout_seconds = 20
+        self.call_timeout_seconds = 60
         self._ensure_event_loop()
-        
+        # stdio 子进程stderr日志文件句柄
+        self._stdio_errlog_file = None
+        # 后台事件循环线程
+        self._loop_thread: Optional[threading.Thread] = None
+
     def _ensure_event_loop(self):
         """
-        确保有可用的事件循环
+        启动一个后台事件循环线程，供所有异步操作使用，避免跨线程无事件循环的问题
         """
-        try:
-            self.event_loop = asyncio.get_event_loop()
-        except RuntimeError:
-            # 如果当前线程没有事件循环，创建一个新的
-            self.event_loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(self.event_loop)
-    
+        if getattr(self, "event_loop", None) and self._loop_thread and self._loop_thread.is_alive():
+            return
+        # 创建独立事件循环并在后台线程中常驻
+        loop = asyncio.new_event_loop()
+        self.event_loop = loop
+
+        def _runner():
+            asyncio.set_event_loop(loop)
+            loop.run_forever()
+
+        t = threading.Thread(target=_runner, name=f"McpClientLoop-{id(self)}", daemon=True)
+        t.start()
+        self._loop_thread = t
+
     async def _connect_async(self):
         """
-        异步连接到MCP服务器
+        异步连接到MCP服务器或本地进程
         """
         try:
             # 创建退出栈
             self.exit_stack = AsyncExitStack()
-            
-            logger.info(f"正在连接到 SSE 服务: {self.server_url}")
-            # 准备请求头，如果有API密钥则添加到请求头中
-            headers = {}
-            if self.api_key:
-                headers['Authorization'] = f'Bearer {self.api_key}'
-                
-            # 增加超时设置
-            streams = await self.exit_stack.enter_async_context(
-                sse_client(url=self.server_url, timeout=60, headers=headers)  # 增加超时时间到60秒并传递请求头
-            )
-            logger.info("SSE 连接已建立")
-            
+
+            if self.transport == "stdio":
+                if not HAS_STDIO:
+                    return False, "未安装或不可用的 MCP stdio 客户端，请确认 mcp 包版本并包含 mcp.client.stdio"
+                cfg = self.stdio_config or {}
+                command = cfg.get("command")
+                if not command:
+                    return False, "本地MCP配置缺少 command"
+                args = cfg.get("args") or []
+                env = cfg.get("env") or None
+                cwd = cfg.get("cwd") or None
+                logger.info(f"正在通过 STDIO 启动本地MCP: {command} {args} (cwd={cwd})")
+                params = StdioServerParameters(
+                    command=command,
+                    args=list(args or []),
+                    env=env,
+                    cwd=cwd,
+                )
+                # 将子进程stderr写入日志文件，便于排查
+                try:
+                    log_dir = os.path.join(os.getcwd(), 'logs')
+                    os.makedirs(log_dir, exist_ok=True)
+                    base = os.path.basename(str(command))
+                    log_path = os.path.join(log_dir, f"mcp_stdio_{base}.log")
+                    self._stdio_errlog_file = open(log_path, 'a', encoding='utf-8')
+                except Exception:
+                    self._stdio_errlog_file = None
+                streams = await self.exit_stack.enter_async_context(
+                    stdio_client(params, errlog=self._stdio_errlog_file or sys.stderr)
+                )
+                logger.info("STDIO 连接已建立")
+            else:
+                logger.info(f"正在连接到 SSE 服务: {self.server_url}")
+                # 准备请求头，如果有API密钥则添加到请求头中
+                headers = {}
+                if self.api_key:
+                    headers['Authorization'] = f'Bearer {self.api_key}'
+                # 增加超时设置
+                streams = await self.exit_stack.enter_async_context(
+                    sse_client(url=self.server_url, timeout=60, headers=headers)  # 增加超时时间到60秒并传递请求头
+                )
+                logger.info("SSE 连接已建立")
+
             # 创建会话
             self.session = await self.exit_stack.enter_async_context(ClientSession(*streams))
-            await self.session.initialize()
+            try:
+                # 为 initialize 增加超时，避免服务器未握手导致阻塞
+                await asyncio.wait_for(self.session.initialize(), timeout=20)
+            except asyncio.TimeoutError:
+                logger.error("会话初始化超时 (initialize) — 请检查本地STDIO服务是否成功启动/输出")
+                return False, "会话初始化超时"
             logger.info("会话已创建")
-            
+
             # 获取工具列表
             logger.info("正在获取工具列表...")
             try:
                 # 使用asyncio.wait_for添加超时控制
-                tools_response = await asyncio.wait_for(self.session.list_tools(), timeout=30)
+                tools_response = await asyncio.wait_for(self.session.list_tools(), timeout=self.list_timeout_seconds)
                 logger.info(f"可用工具: {tools_response}")
-                
+
                 # 提取工具列表
                 if hasattr(tools_response, 'tools') and tools_response.tools:
                     self.tools = tools_response.tools
                 else:
                     # 如果返回的是直接的工具列表
                     self.tools = tools_response
-                
+
                 self.connected = True
                 return True, self.tools
             except asyncio.TimeoutError:
                 logger.error("获取工具列表超时")
                 return False, "获取工具列表超时"
-                
+
         except Exception as e:
             logger.error(f"连接或调用过程中出错: {e}")
             error_msg = str(e)
-            # 检查是否是网络相关错误
-            if "connection" in error_msg.lower() or "timeout" in error_msg.lower():
-                logger.error("网络连接问题，请检查网络或服务器状态")
-                return False, "网络连接问题，请检查网络或服务器状态"
-            # 检查是否是认证错误
-            elif "auth" in error_msg.lower() or "unauthorized" in error_msg.lower():
-                logger.error("可能存在认证问题，请检查是否需要提供 API 密钥")
-                return False, "认证问题，请检查是否需要提供 API 密钥"
-            # 检查是否是SSE相关错误
-            elif "sse" in error_msg.lower() or "stream" in error_msg.lower():
-                logger.error("SSE流处理错误，可能是服务器提前关闭了连接")
-                return False, "SSE流处理错误，可能是服务器提前关闭了连接"
+            # 分类错误信息
+            if self.transport == "sse":
+                if "connection" in error_msg.lower() or "timeout" in error_msg.lower():
+                    logger.error("网络连接问题，请检查网络或服务器状态")
+                    return False, "网络连接问题，请检查网络或服务器状态"
+                elif "auth" in error_msg.lower() or "unauthorized" in error_msg.lower():
+                    logger.error("可能存在认证问题，请检查是否需要提供 API 密钥")
+                    return False, "认证问题，请检查是否需要提供 API 密钥"
+                elif "sse" in error_msg.lower() or "stream" in error_msg.lower():
+                    logger.error("SSE流处理错误，可能是服务器提前关闭了连接")
+                    return False, "SSE流处理错误，可能是服务器提前关闭了连接"
+            else:
+                if "command" in error_msg.lower() or "not found" in error_msg.lower():
+                    return False, "本地MCP命令启动失败，请检查 command/args/cwd 是否正确"
             return False, f"连接错误: {error_msg}"
-    
+
     def connect(self):
         """
-        连接到MCP服务器
+        连接到MCP服务器（提交到后台事件循环）
         :return: (是否成功, 工具列表或错误信息)
         """
-        return self.event_loop.run_until_complete(self._connect_async())
-    
+        fut = asyncio.run_coroutine_threadsafe(self._connect_async(), self.event_loop)
+        return fut.result(timeout=self.init_timeout_seconds + self.list_timeout_seconds + 10)
+
     async def _call_tool_async(self, method, params=None):
         """
         异步调用MCP工具
@@ -120,37 +198,39 @@ class McpClient:
         """
         if not self.connected or not self.session:
             return False, "未连接到MCP服务器"
-            
+
         try:
             if params is None:
                 params = {}
-                
+
             logger.info(f"调用工具: {method}, 参数: {params}")
-            result = await asyncio.wait_for(self.session.call_tool(method, params), timeout=30)
+            result = await asyncio.wait_for(self.session.call_tool(method, params), timeout=self.call_timeout_seconds)
             logger.info(f"调用结果: {result}")
             return True, result
+        except asyncio.TimeoutError:
+            return False, f"调用工具超时({self.call_timeout_seconds}s)"
         except Exception as e:
-            return False, f"调用工具失败: {str(e)}"
-    
+            # 提供更可读的错误类型，并在日志中打印完整异常，便于排查
+            logger.exception("调用工具失败异常堆栈")
+            msg = str(e)
+            if not msg:
+                msg = repr(e)
+            return False, f"调用工具失败: {type(e).__name__}: {msg}"
+
     def call_tool(self, method, params=None):
         """
-        调用MCP工具
+        调用MCP工具（提交到后台事件循环）
         :param method: 方法名
         :param params: 参数字典
         :return: (是否成功, 结果或错误信息)
         """
         try:
-            # 确保在同一个事件循环中执行
-            if asyncio.get_event_loop() != self.event_loop:
-                return self.event_loop.run_until_complete(self._call_tool_async(method, params))
-            else:
-                # 如果已经在事件循环中，创建一个新的任务并等待它完成
-                future = asyncio.run_coroutine_threadsafe(self._call_tool_async(method, params), self.event_loop)
-                return future.result(timeout=30)
+            future = asyncio.run_coroutine_threadsafe(self._call_tool_async(method, params), self.event_loop)
+            return future.result(timeout=self.call_timeout_seconds + 5)
         except Exception as e:
             util.log(1, f"调用MCP工具时出错: {str(e)}")
             return False, f"调用工具失败: {str(e)}"
-    
+
     def list_tools(self):
         """
         获取可用工具列表
@@ -161,16 +241,28 @@ class McpClient:
             if not success:
                 return []
         return self.tools or []
-    
+
     def disconnect(self):
         """
         断开与MCP服务器的连接
         """
         if self.connected and self.exit_stack:
             try:
-                self.event_loop.run_until_complete(self.exit_stack.aclose())
-                self.connected = False
-                self.session = None
+                # 在后台事件循环中关闭资源
+                try:
+                    if self.exit_stack:
+                        fut = asyncio.run_coroutine_threadsafe(self.exit_stack.aclose(), self.event_loop)
+                        fut.result(timeout=10)
+                finally:
+                    self.connected = False
+                    self.session = None
+                    # 关闭子进程stderr日志文件
+                    try:
+                        if self._stdio_errlog_file:
+                            self._stdio_errlog_file.close()
+                            self._stdio_errlog_file = None
+                    except Exception:
+                        pass
                 logger.info("已断开与MCP服务器的连接")
                 return True
             except Exception as e:
diff --git a/faymcp/mcp_service.py b/faymcp/mcp_service.py
index 6bcf7e5..4d2d395 100644
--- a/faymcp/mcp_service.py
+++ b/faymcp/mcp_service.py
@@ -4,6 +4,7 @@
 from flask import Flask, render_template, request, jsonify, redirect, url_for
 import os
 import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
 import json
 import time
 import threading
@@ -13,6 +14,8 @@ from flask_cors import CORS
 from faymcp.mcp_client import McpClient
 from utils import util
 
+
+
 # 创建Flask应用
 app = Flask(__name__)
 
@@ -23,6 +26,9 @@ CORS(app, resources={r"/*": {"origins": "*"}})
 # MCP服务器数据文件路径
 MCP_DATA_FILE = os.path.join(os.path.dirname(__file__), 'data', 'mcp_servers.json')
 
+# MCP工具状态数据文件路径
+MCP_TOOL_STATES_FILE = os.path.join(os.path.dirname(__file__), 'data', 'mcp_tool_states.json')
+
 # 确保data目录存在
 os.makedirs(os.path.dirname(MCP_DATA_FILE), exist_ok=True)
 
@@ -32,6 +38,9 @@ mcp_clients = {}
 # 存储MCP服务器工具列表的字典，键为服务器ID
 mcp_tools = {}
 
+# 存储工具状态的字典，键为服务器ID，值为工具名称->状态的字典
+mcp_tool_states = {}
+
 # 连接检查定时器
 connection_check_timer = None
 
@@ -61,6 +70,42 @@ def load_mcp_servers():
         util.log(1, f"加载MCP服务器数据失败: {e}")
         return default_mcp_servers
 
+# 加载MCP工具状态数据
+def load_mcp_tool_states():
+    try:
+        if os.path.exists(MCP_TOOL_STATES_FILE):
+            with open(MCP_TOOL_STATES_FILE, 'r', encoding='utf-8') as f:
+                states = json.load(f)
+                # 转换字符串键为整数（因为JSON中的键总是字符串）
+                converted_states = {}
+                for server_id_str, tools in states.items():
+                    try:
+                        server_id = int(server_id_str)
+                        converted_states[server_id] = tools
+                    except ValueError:
+                        continue
+                return converted_states
+        else:
+            return {}
+    except Exception as e:
+        util.log(1, f"加载MCP工具状态数据失败: {e}")
+        return {}
+
+# 保存MCP工具状态数据
+def save_mcp_tool_states():
+    try:
+        # 转换整数键为字符串（JSON要求）
+        states_to_save = {}
+        for server_id, tools in mcp_tool_states.items():
+            states_to_save[str(server_id)] = tools
+            
+        with open(MCP_TOOL_STATES_FILE, 'w', encoding='utf-8') as f:
+            json.dump(states_to_save, f, ensure_ascii=False, indent=4)
+        return True
+    except Exception as e:
+        util.log(1, f"保存MCP工具状态数据失败: {e}")
+        return False
+
 # 保存MCP服务器数据
 def save_mcp_servers(servers):
     try:
@@ -71,9 +116,14 @@ def save_mcp_servers(servers):
             server_copy = {
                 "id": server['id'],
                 "name": server['name'],
-                "ip": server['ip'],
+                "ip": server.get('ip', ''),
                 "connection_time": server.get('connection_time', ''),
-                "key": server.get('key', '')  # 保存Key字段
+                "key": server.get('key', ''),  # 保存Key字段
+                "transport": server.get('transport', 'sse'),
+                "command": server.get('command', ''),
+                "args": server.get('args', []),
+                "cwd": server.get('cwd', ''),
+                "env": server.get('env', {})
             }
             servers_to_save.append(server_copy)
             
@@ -87,6 +137,24 @@ def save_mcp_servers(servers):
 # 初始化MCP服务器数据
 mcp_servers = load_mcp_servers()
 
+# 初始化MCP工具状态数据
+mcp_tool_states = load_mcp_tool_states()
+
+# 工具状态管理函数
+def get_tool_state(server_id, tool_name):
+    """获取工具的启用状态，默认为True"""
+    if server_id not in mcp_tool_states:
+        mcp_tool_states[server_id] = {}
+    return mcp_tool_states[server_id].get(tool_name, True)
+
+def set_tool_state(server_id, tool_name, enabled):
+    """设置工具的启用状态"""
+    if server_id not in mcp_tool_states:
+        mcp_tool_states[server_id] = {}
+    mcp_tool_states[server_id][tool_name] = enabled
+    # 立即保存到文件
+    save_mcp_tool_states()
+
 # 连接真实MCP服务器
 def connect_to_real_mcp(server):
     """
@@ -96,15 +164,39 @@ def connect_to_real_mcp(server):
     """
     global mcp_clients
     try:
-        # 获取服务器IP、ID和Key
-        ip = server['ip']
+        # 获取服务器配置
         server_id = server['id']
-        api_key = server.get('key', '')  # 获取Key，如果不存在则为空字符串
+        transport = server.get('transport', 'sse')
+        api_key = server.get('key', '')  # 获取Key
         
-        # 构建MCP服务器端点URL
-        endpoint = ip
-        # 创建MCP客户端，传入API密钥
-        client = McpClient(endpoint, api_key)
+        # 如果已存在旧连接，先断开并清理（防止重复连接）
+        if server_id in mcp_clients:
+            try:
+                old_client = mcp_clients[server_id]
+                if hasattr(old_client, 'disconnect'):
+                    old_client.disconnect()
+                # util.log(1, f"已断开服务器 {server['name']} (ID: {server_id}) 的旧连接")
+            except Exception as e:
+                pass  # 静默处理断开旧连接的错误
+            del mcp_clients[server_id]
+        
+        client = None
+        if transport == 'stdio':
+            # 统一默认工作目录为项目根目录（faymcp 的上一级），避免相对路径在不同启动目录下失效
+            repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+            cfg_cwd = server.get('cwd')
+            cwd = cfg_cwd if (cfg_cwd and str(cfg_cwd).strip()) else repo_root
+            stdio_config = {
+                "command": server.get('command'),
+                "args": server.get('args', []) or [],
+                "cwd": cwd,
+                "env": (server.get('env') or None),
+            }
+            client = McpClient(server_url=None, api_key=None, transport='stdio', stdio_config=stdio_config)
+        else:
+            ip = server.get('ip', '')
+            endpoint = ip
+            client = McpClient(endpoint, api_key)
         
         # 记录开始时间
         start_time = time.time()
@@ -156,6 +248,54 @@ def get_mcp_client(server_id):
     """
     return mcp_clients.get(server_id)
 
+# 断开所有MCP服务连接
+def disconnect_all_mcp_servers():
+    """
+    断开所有MCP服务器连接，清理资源
+    """
+    global mcp_clients, mcp_tools, mcp_servers, connection_check_timer
+    
+    util.log(1, f'开始断开 {len(mcp_clients)} 个MCP服务连接...')
+    
+    # 停止连接检查定时器
+    if connection_check_timer:
+        try:
+            connection_check_timer.cancel()
+            util.log(1, '连接检查定时器已停止')
+        except Exception as e:
+            util.log(1, f'停止连接检查定时器失败: {e}')
+        connection_check_timer = None
+    
+    # 断开所有MCP客户端连接
+    disconnected_count = 0
+    for server_id, client in list(mcp_clients.items()):
+        try:
+            if hasattr(client, 'disconnect'):
+                client.disconnect()
+            elif hasattr(client, 'close'):
+                client.close()
+            disconnected_count += 1
+            util.log(1, f'已断开MCP服务器连接: ID {server_id}')
+        except Exception as e:
+            util.log(1, f'断开MCP服务器连接失败 (ID: {server_id}): {e}')
+    
+    # 清理所有数据
+    mcp_clients.clear()
+    mcp_tools.clear()
+    
+    # 更新所有服务器状态为离线
+    for server in mcp_servers:
+        server['status'] = 'offline'
+        server['latency'] = '0ms'
+    
+    # 保存服务器状态
+    try:
+        save_mcp_servers(mcp_servers)
+    except Exception as e:
+        util.log(1, f'保存MCP服务器状态失败: {e}')
+    
+    util.log(1, f'成功断开 {disconnected_count} 个MCP服务连接，资源已清理')
+
 # 调用MCP服务器工具
 def call_mcp_tool(server_id, method, params=None):
     """
@@ -166,6 +306,10 @@ def call_mcp_tool(server_id, method, params=None):
     :return: (是否成功, 结果或错误信息)
     """
     try:
+        # 检查工具是否被启用
+        if not get_tool_state(server_id, method):
+            return False, f"工具 '{method}' 已被禁用"
+        
         # 获取客户端对象
         client = get_mcp_client(server_id)
         if not client:
@@ -204,25 +348,35 @@ def add_mcp_server():
     data = request.json
     
     # 验证必要字段
-    required_fields = ['name', 'ip']
-    for field in required_fields:
-        if field not in data:
-            return jsonify({"error": f"缺少必要字段: {field}"}), 400
-    
+    transport = data.get('transport', 'sse')
+    if transport == 'stdio':
+        if 'name' not in data or 'command' not in data:
+            return jsonify({"error": "缺少必要字段: name 或 command"}), 400
+    else:
+        required_fields = ['name', 'ip']
+        for field in required_fields:
+            if field not in data:
+                return jsonify({"error": f"缺少必要字段: {field}"}), 400
+
     # 生成新ID (当前最大ID + 1)
     new_id = 1
     if mcp_servers:
         new_id = max(server['id'] for server in mcp_servers) + 1
-    
+
     # 创建新服务器对象
     new_server = {
         "id": new_id,
         "name": data['name'],
         "status": "offline",
-        "ip": data['ip'],
+        "ip": data.get('ip', ''),
         "latency": "0ms",
         "connection_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-        "key": data.get('key', '')  # 添加Key字段，如果不存在则为空字符串
+        "key": data.get('key', ''),  # 添加Key字段
+        "transport": transport,
+        "command": data.get('command', ''),
+        "args": data.get('args', []),
+        "cwd": data.get('cwd', ''),
+        "env": data.get('env', {})
     }
     
     # 如果请求中包含 auto_connect 字段并且为 True，则尝试连接
@@ -245,9 +399,11 @@ def add_mcp_server():
                         for tool in tools:
                             if hasattr(tool, 'name'):
                                 # 如果是对象，转换为字典
+                                tool_name = str(getattr(tool, 'name', '未知'))
                                 tool_dict = {
-                                    'name': str(getattr(tool, 'name', '未知')),
+                                    'name': tool_name,
                                     'description': str(getattr(tool, 'description', '')),
+                                    'enabled': get_tool_state(server_id, tool_name)
                                 }
                                 
                                 # 处理 inputSchema
@@ -261,18 +417,31 @@ def add_mcp_server():
                             else:
                                 # 如果是字典
                                 if isinstance(tool, dict) and 'name' in tool:
+                                    tool_name = str(tool.get('name', '未知'))
                                     tools_list.append({
-                                        'name': str(tool.get('name', '未知')),
+                                        'name': tool_name,
                                         'description': str(tool.get('description', '')),
-                                        'inputSchema': tool.get('inputSchema', {})
+                                        'inputSchema': tool.get('inputSchema', {}),
+                                        'enabled': get_tool_state(server_id, tool_name)
                                     })
                                 else:
                                     # 其他情况，尝试转换为字符串
-                                    tools_list.append({'name': str(tool), 'description': ''})
+                                    tool_name = str(tool)
+                                    tools_list.append({
+                                        'name': tool_name, 
+                                        'description': '',
+                                        'enabled': get_tool_state(server_id, tool_name)
+                                    })
                     except Exception as e:
                         util.log(1, f"工具列表序列化失败: {e}")
                         # 如果转换失败，只返回工具名称
-                        tools_list = [{'name': str(tool)} for tool in tools]
+                        tools_list = []
+                        for tool in tools:
+                            tool_name = str(tool)
+                            tools_list.append({
+                                'name': tool_name,
+                                'enabled': get_tool_state(server_id, tool_name)
+                            })
                 
         except Exception as e:
             util.log(1, f"自动连接失败: {e}")
@@ -493,11 +662,22 @@ def get_server_tools(server_id):
             
             # 检查是否已有缓存的工具列表
             if server_id in mcp_tools and mcp_tools[server_id]:
-                # 使用缓存的工具列表，添加到结果中
+                # 使用缓存的工具列表，但需要更新enabled状态
+                cached_tools = mcp_tools[server_id]
+                updated_tools = []
+                for tool in cached_tools:
+                    if isinstance(tool, dict) and 'name' in tool:
+                        tool_name = tool['name']
+                        updated_tool = tool.copy()
+                        updated_tool['enabled'] = get_tool_state(server_id, tool_name)
+                        updated_tools.append(updated_tool)
+                    else:
+                        updated_tools.append(tool)
+                
                 return jsonify({
                     "success": True,
-                    "message": "获取工具列表成功（缓存）",
-                    "tools": mcp_tools[server_id]
+                    "message": "获取工具列表成功（缓存+状态更新）",
+                    "tools": updated_tools
                 })
                 
             # 获取客户端对象
@@ -521,9 +701,11 @@ def get_server_tools(server_id):
                         for tool in tools:
                             if hasattr(tool, 'name'):
                                 # 如果是对象，转换为字典
+                                tool_name = str(getattr(tool, 'name', '未知'))
                                 tool_dict = {
-                                    'name': str(getattr(tool, 'name', '未知')),
+                                    'name': tool_name,
                                     'description': str(getattr(tool, 'description', '')),
+                                    'enabled': get_tool_state(server_id, tool_name)
                                 }
                                 
                                 # 处理 inputSchema
@@ -537,18 +719,31 @@ def get_server_tools(server_id):
                             else:
                                 # 如果是字典
                                 if isinstance(tool, dict) and 'name' in tool:
+                                    tool_name = str(tool.get('name', '未知'))
                                     tools_list.append({
-                                        'name': str(tool.get('name', '未知')),
+                                        'name': tool_name,
                                         'description': str(tool.get('description', '')),
-                                        'inputSchema': tool.get('inputSchema', {})
+                                        'inputSchema': tool.get('inputSchema', {}),
+                                        'enabled': get_tool_state(server_id, tool_name)
                                     })
                                 else:
                                     # 其他情况，尝试转换为字符串
-                                    tools_list.append({'name': str(tool), 'description': ''})
+                                    tool_name = str(tool)
+                                    tools_list.append({
+                                        'name': tool_name, 
+                                        'description': '',
+                                        'enabled': get_tool_state(server_id, tool_name)
+                                    })
                     except Exception as e:
                         util.log(1, f"工具列表序列化失败: {e}")
                         # 如果转换失败，只返回工具名称
-                        tools_list = [{'name': str(tool)} for tool in tools]
+                        tools_list = []
+                        for tool in tools:
+                            tool_name = str(tool)
+                            tools_list.append({
+                                'name': tool_name,
+                                'enabled': get_tool_state(server_id, tool_name)
+                            })
                 
                 # 保存工具列表到全局字典中
                 mcp_tools[server_id] = tools_list
@@ -585,8 +780,18 @@ def get_all_online_server_tools():
             
             # 检查是否有缓存的工具列表
             if server_id in mcp_tools and mcp_tools[server_id]:
-                # 使用缓存的工具列表，添加到结果中
-                all_tools.extend(mcp_tools[server_id])
+                # 使用缓存的工具列表，但需要更新enabled状态
+                cached_tools = mcp_tools[server_id]
+                updated_tools = []
+                for tool in cached_tools:
+                    if isinstance(tool, dict) and 'name' in tool:
+                        tool_name = tool['name']
+                        updated_tool = tool.copy()
+                        updated_tool['enabled'] = get_tool_state(server_id, tool_name)
+                        updated_tools.append(updated_tool)
+                    else:
+                        updated_tools.append(tool)
+                all_tools.extend(updated_tools)
             else:
                 # 获取客户端对象
                 client = get_mcp_client(server_id)
@@ -690,8 +895,12 @@ def call_mcp_tool_direct(tool_name):
             tools = client.list_tools()
             tool_names = [str(getattr(tool, 'name', tool)) for tool in tools]
             
-            # 检查工具是否存在
+            # 检查工具是否存在且被启用
             if tool_name in tool_names:
+                # 检查工具是否被启用
+                if not get_tool_state(server_id, tool_name):
+                    continue  # 如果工具被禁用，跳过这个服务器
+                
                 # 调用工具
                 success, result = call_mcp_tool(server_id, tool_name, params)
                 
@@ -835,6 +1044,49 @@ def schedule_connection_check():
     connection_check_timer.daemon = True  # 设置为守护线程，这样主程序退出时它会自动结束
     connection_check_timer.start()
 
+# API路由 - 切换工具状态
+@app.route('/api/mcp/servers/<int:server_id>/tools/<string:tool_name>/toggle', methods=['POST'])
+def toggle_tool_state(server_id, tool_name):
+    """
+    切换工具的启用/禁用状态
+    """
+    try:
+        # 获取请求数据
+        data = request.json or {}
+        enabled = data.get('enabled', True)
+        
+        # 验证服务器是否存在
+        server = None
+        for s in mcp_servers:
+            if s['id'] == server_id:
+                server = s
+                break
+        
+        if not server:
+            return jsonify({
+                "success": False,
+                "message": "服务器不存在"
+            }), 404
+        
+        # 设置工具状态
+        set_tool_state(server_id, tool_name, enabled)
+        
+        util.log(1, f"工具 {tool_name} 在服务器 {server['name']} 上已{'启用' if enabled else '禁用'}")
+        
+        return jsonify({
+            "success": True,
+            "message": f"工具 {tool_name} 已{'启用' if enabled else '禁用'}",
+            "tool_name": tool_name,
+            "enabled": enabled
+        })
+        
+    except Exception as e:
+        util.log(1, f"切换工具状态失败: {e}")
+        return jsonify({
+            "success": False,
+            "message": f"切换工具状态失败: {str(e)}"
+        }), 500
+
 # 启动连接检查
 def start_connection_check():
     """
@@ -870,3 +1122,10 @@ def start():
     # 启动服务器
     from scheduler.thread_manager import MyThread
     MyThread(target=run).start()
+
+if __name__ == '__main__':
+    import logging
+    logging.basicConfig(level=logging.DEBUG)
+    app.logger.setLevel(logging.DEBUG)
+    logging.getLogger('werkzeug').setLevel(logging.DEBUG)
+    app.run(host='0.0.0.0', port=5010, debug=True)
\ No newline at end of file
diff --git a/faymcp/templates/Page3.html b/faymcp/templates/Page3.html
index f426509..23d0d55 100644
--- a/faymcp/templates/Page3.html
+++ b/faymcp/templates/Page3.html
@@ -292,17 +292,82 @@
         flex-wrap: wrap;
       }
       .mcp-info-item {
-        width: 33.33%;
+        width: 50%;
         margin-bottom: 10px;
         display: flex;
       }
+      /* 让工具列表占满整行 */
+      .mcp-info-item:nth-child(4) {
+        width: 100%;
+        flex-direction: column;
+        align-items: flex-start;
+      }
+      /* 工具列表容器样式 */
+      .tools-container {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 10px;
+        margin-top: 5px;
+        width: 100%;
+      }
+      /* 工具按钮样式 */
+      .tool-btn {
+        padding: 6px 12px;
+        border-radius: 20px;
+        border: 1px solid #dcdfe6;
+        background-color: #fff;
+        color: #606266;
+        cursor: pointer;
+        transition: all 0.3s;
+        font-size: 14px;
+        display: inline-flex;
+        align-items: center;
+        gap: 5px;
+        user-select: none;
+      }
+      .tool-btn:hover {
+        border-color: #409eff;
+        color: #409eff;
+      }
+      /* 工具启用状态 */
+      .tool-btn.enabled {
+        background-color: #409eff;
+        color: #fff;
+        border-color: #409eff;
+      }
+      .tool-btn.enabled:hover {
+        background-color: #66b1ff;
+        border-color: #66b1ff;
+      }
+      /* 工具禁用状态 */
+      .tool-btn.disabled {
+        background-color: #f5f7fa;
+        color: #c0c4cc;
+        border-color: #e4e7ed;
+        cursor: not-allowed;
+      }
+      /* 状态指示点 */
+      .tool-status-dot {
+        width: 6px;
+        height: 6px;
+        border-radius: 50%;
+        background-color: #c0c4cc;
+      }
+      .tool-btn.enabled .tool-status-dot {
+        background-color: #67c23a;
+      }
       .mcp-info-label {
         font-weight: bold;
         width: 100px;
         color: #606266;
+        flex-shrink: 0;
+        margin-right: 10px;
       }
       .mcp-info-value {
         color: #303133;
+        flex: 1;
+        word-break: break-word;
+        line-height: 1.5;
       }
       /* 让 main_right 成为定位上下文 */
       .main_right {
@@ -337,7 +402,7 @@
           <div class="mcp-container">
             <!-- 使用Jinja2模板循环渲染MCP服务器卡片 -->
             {% for server in mcp_servers %}
-            <div class="mcp-card tooltip" data-server-id="{{ server.id }}">
+            <div class="mcp-card tooltip" data-server-id="{{ server.id }}" data-transport="{{ server.transport or 'sse' }}" data-command="{{ server.command or '' }}" data-args="{{ (server.args | join(' ')) if server.args else '' }}" data-cwd="{{ server.cwd or '' }}">
               <div class="mcp-header">
                 <div class="mcp-title">{{ server.name }}</div>
                 <div class="status-{{ server.status }}">
@@ -387,12 +452,41 @@
                     <input type="text" class="mcp-input" id="mcpName" placeholder="请输入名称">
                   </div>
                   <div class="mcp-form-item">
-                    <label class="mcp-label">SSE服务器:</label>
-                    <input type="text" class="mcp-input" id="mcpIp" placeholder="请输入SSE地址">
+                    <label class="mcp-label">类型:</label>
+                    <select class="mcp-input" id="mcpTransport">
+                      <option value="sse" selected>SSE（远程）</option>
+                      <option value="stdio">STDIO（本地）</option>
+                    </select>
                   </div>
-                  <div class="mcp-form-item">
-                    <label class="mcp-label">Key:</label>
-                    <input type="text" class="mcp-input" id="mcpKey" placeholder="（可留空）请输入Key">
+                  <!-- SSE 配置 -->
+                  <div id="sseFields">
+                    <div class="mcp-form-item">
+                      <label class="mcp-label">SSE服务器:</label>
+                      <input type="text" class="mcp-input" id="mcpIp" placeholder="请输入SSE地址">
+                    </div>
+                    <div class="mcp-form-item">
+                      <label class="mcp-label">Key:</label>
+                      <input type="text" class="mcp-input" id="mcpKey" placeholder="（可留空）请输入Key">
+                    </div>
+                  </div>
+                  <!-- STDIO 配置 -->
+                  <div id="stdioFields" style="display:none;">
+                    <div class="mcp-form-item">
+                      <label class="mcp-label">命令:</label>
+                      <input type="text" class="mcp-input" id="mcpCommand" placeholder="例如: node">
+                    </div>
+                    <div class="mcp-form-item">
+                      <label class="mcp-label">参数:</label>
+                      <input type="text" class="mcp-input" id="mcpArgs" placeholder='例如: ./servers/fs-server.js --port 0'>
+                    </div>
+                    <div class="mcp-form-item">
+                      <label class="mcp-label">工作目录:</label>
+                      <input type="text" class="mcp-input" id="mcpCwd" placeholder="可留空，默认当前目录">
+                    </div>
+                    <div class="mcp-form-item">
+                      <label class="mcp-label">环境变量(JSON):</label>
+                      <input type="text" class="mcp-input" id="mcpEnv" placeholder='例如: {"MODE":"local"}'>
+                    </div>
                   </div>
                 </div>
                 <div class="mcp-dialog-footer">
@@ -414,7 +508,7 @@
               </div>
               <div class="mcp-info-item">
                 <span class="mcp-info-label">服务器类型:</span>
-                <span class="mcp-info-value">SSE</span>
+                <span class="mcp-info-value">--</span>
               </div>
               <div class="mcp-info-item">
                 <span class="mcp-info-label">延迟:</span>
@@ -422,7 +516,11 @@
               </div>
               <div class="mcp-info-item">
                 <span class="mcp-info-label">可用工具:</span>
-                <span class="mcp-info-value">--</span>
+                <div class="mcp-info-value">
+                  <div class="tools-container" id="toolsContainer">
+                    <span style="color: #909399;">--</span>
+                  </div>
+                </div>
               </div>
             </div>
           </div>
@@ -446,24 +544,43 @@
         console.log("添加按钮被点击");
         // 获取输入值
         const name = document.getElementById('mcpName').value.trim();
-        const ip = document.getElementById('mcpIp').value.trim();
-        const key = document.getElementById('mcpKey').value.trim();
-        
-        console.log("输入值:", name, ip, key ? "(Key已输入)" : "(无Key)");
-        
-        // 简单验证
-        if (!name || !ip) {
-          alert('请填写完整的MCP信息');
-          return;
+        const transport = document.getElementById('mcpTransport').value;
+
+        let data = { name, transport };
+        if (transport === 'stdio') {
+          const command = document.getElementById('mcpCommand').value.trim();
+          const argsStr = document.getElementById('mcpArgs').value.trim();
+          const cwd = document.getElementById('mcpCwd').value.trim();
+          const envStr = document.getElementById('mcpEnv').value.trim();
+
+          if (!name || !command) {
+            alert('请填写名称与命令');
+            return;
+          }
+
+          let args = [];
+          if (argsStr) {
+            // 简单按空格拆分，支持引号可后续优化
+            args = argsStr.match(/\"[^\"]*\"|'[^']*'|[^\s]+/g) || [];
+            args = args.map(s => s.replace(/^"|"$/g, '').replace(/^'|'$/g, ''));
+          }
+
+          let env = {};
+          if (envStr) {
+            try { env = JSON.parse(envStr); } catch (e) { alert('环境变量需为合法JSON'); return; }
+          }
+
+          data = { ...data, command, args, cwd, env };
+        } else {
+          const ip = document.getElementById('mcpIp').value.trim();
+          const key = document.getElementById('mcpKey').value.trim();
+          if (!name || !ip) {
+            alert('请填写名称与SSE地址');
+            return;
+          }
+          data = { ...data, ip, key };
         }
         
-        // 准备数据
-        const data = {
-          name: name,
-          ip: ip,
-          key: key  // 添加 Key 参数
-        };
-        
         console.log("准备发送数据:", JSON.stringify(data));
         
         // 发送请求到后端
@@ -514,6 +631,22 @@
         } else {
           console.error('找不到添加服务器按钮元素');
         }
+
+        // 绑定类型切换，显示/隐藏字段
+        const transportSel = document.getElementById('mcpTransport');
+        const sseFields = document.getElementById('sseFields');
+        const stdioFields = document.getElementById('stdioFields');
+        if (transportSel) {
+          transportSel.addEventListener('change', function() {
+            if (this.value === 'stdio') {
+              sseFields.style.display = 'none';
+              stdioFields.style.display = 'block';
+            } else {
+              sseFields.style.display = 'block';
+              stdioFields.style.display = 'none';
+            }
+          });
+        }
       });
 
       // 删除MCP服务器
@@ -639,22 +772,18 @@
               // 更新信息面板
               updateInfoPanel(data.server, toolsInfo);
               
-              // 选中当前卡片
-              mcpCards.forEach(c => c.classList.remove('selected'));
+              // 选中当前卡片并更新面板
+              document.querySelectorAll('.mcp-card.selected').forEach(c => c.classList.remove('selected'));
               card.classList.add('selected');
-              
-              // 触发卡片点击事件，更新信息卡片
-              card.click();
+              onCardSelected(card);
             } else {
               // 没有工具时也更新信息面板
               updateInfoPanel(data.server, '无可用工具');
               
-              // 选中当前卡片
-              mcpCards.forEach(c => c.classList.remove('selected'));
+              // 选中当前卡片并更新面板
+              document.querySelectorAll('.mcp-card.selected').forEach(c => c.classList.remove('selected'));
               card.classList.add('selected');
-              
-              // 触发卡片点击事件，更新信息卡片
-              card.click();
+              onCardSelected(card);
             }
           } else {
             // 连接失败
@@ -796,22 +925,18 @@
               // 更新信息面板
               updateInfoPanel(data.server, toolsInfo);
               
-              // 选中当前卡片
-              mcpCards.forEach(c => c.classList.remove('selected'));
+              // 选中当前卡片并更新面板
+              document.querySelectorAll('.mcp-card.selected').forEach(c => c.classList.remove('selected'));
               card.classList.add('selected');
-              
-              // 触发卡片点击事件，更新信息卡片
-              card.click();
+              onCardSelected(card);
             } else {
               // 没有工具时也更新信息面板
               updateInfoPanel(data.server, '无可用工具');
               
-              // 选中当前卡片
-              mcpCards.forEach(c => c.classList.remove('selected'));
+              // 选中当前卡片并更新面板
+              document.querySelectorAll('.mcp-card.selected').forEach(c => c.classList.remove('selected'));
               card.classList.add('selected');
-              
-              // 触发卡片点击事件，更新信息卡片
-              card.click();
+              onCardSelected(card);
             }
           } else {
             // 连接失败
@@ -855,9 +980,10 @@
       
       // 卡片选中功能
       const mcpCards = document.querySelectorAll('.mcp-card');
+      const container = document.querySelector('.mcp-container');
       const infoPanel = document.querySelector('.mcp-info-panel');
       const infoValues = document.querySelectorAll('.mcp-info-value');
-      
+
       // 处理长文本，超出长度使用省略号替代
       function truncateText(text, maxLength = 30) {
         if (!text) return '';
@@ -865,83 +991,179 @@
         return text.substring(0, maxLength - 3) + '...';
       }
       
-      mcpCards.forEach((card, index) => {
-        // 处理卡片中的服务器地址，如果太长则使用省略号替代
-        const ipValue = card.querySelector('.mcp-info:nth-child(2) .mcp-value');
-        if (ipValue) {
-          ipValue.textContent = truncateText(ipValue.textContent);
-          // 添加完整地址的 title 属性，鼠标悬停时显示完整地址
-          ipValue.title = ipValue.getAttribute('data-full-ip') || ipValue.textContent;
+      // 首次渲染：处理省略显示
+      mcpCards.forEach((card) => {
+        const ipNode = card.querySelector('.mcp-info:nth-child(2) .mcp-value');
+        if (ipNode) {
+          const full = ipNode.getAttribute('data-full-ip') || ipNode.textContent;
+          ipNode.textContent = truncateText(full);
+          ipNode.title = full;
         }
-        
-        card.addEventListener('click', () => {
-          // 移除其他卡片的选中状态
-          mcpCards.forEach(c => c.classList.remove('selected'));
-          
-          // 添加当前卡片的选中状态
-          card.classList.add('selected');
-          
-          // 显示信息面板
-          infoPanel.classList.add('active');
-          
-          // 获取服务器ID和信息
-          const serverId = card.getAttribute('data-server-id');
-          const serverName = card.querySelector('.mcp-title').textContent;
-          const serverIp = card.querySelector('.mcp-info:nth-child(2) .mcp-value').getAttribute('data-full-ip') || 
-                           card.querySelector('.mcp-info:nth-child(2) .mcp-value').textContent;
-          const serverLatency = card.querySelector('.mcp-info:nth-child(3) .mcp-value').textContent;
-          const serverStatus = card.querySelector('.status-online, .status-offline').className;
-          
-          // 更新信息面板内容
-          const ipValue = infoPanel.querySelector('.mcp-info-item:nth-child(1) .mcp-info-value');
-          const typeValue = infoPanel.querySelector('.mcp-info-item:nth-child(2) .mcp-info-value');
-          const latencyValue = infoPanel.querySelector('.mcp-info-item:nth-child(3) .mcp-info-value');
-          const toolsValue = infoPanel.querySelector('.mcp-info-item:nth-child(4) .mcp-info-value');
-          
-          if (ipValue) {
-            ipValue.textContent = truncateText(serverIp);
-            ipValue.title = serverIp; // 添加完整地址的 title 属性
-          }
-          if (latencyValue) latencyValue.textContent = serverLatency;
-          
-          // 如果服务器在线，获取工具列表
-          if (serverStatus.includes('online')) {
-            // 显示加载状态
-            if (toolsValue) toolsValue.textContent = '加载中...';
-            
-            // 发送请求获取工具列表
-            fetch(`/api/mcp/servers/${serverId}/tools`, {
-              method: 'GET'
-            })
-            .then(response => response.json())
-            .then(data => {
-              if (data.success && data.tools && data.tools.length > 0) {
-                const toolNames = data.tools.map(tool => {
-                  if (typeof tool === 'object' && tool !== null && tool.name) {
-                    return tool.name;
-                  } else if (typeof tool === 'string') {
-                    return tool;
-                  } else {
-                    return '未知工具';
-                  }
-                });
-                
-                toolsValue.textContent = toolNames.join(', ');
-              } else {
-                toolsValue.textContent = '无可用工具';
-              }
-            })
-            .catch(error => {
-              console.error('获取工具列表失败:', error);
-              toolsValue.textContent = '获取工具列表失败';
-            });
-          } else {
-            // 服务器离线
-            if (toolsValue) toolsValue.textContent = '服务器离线';
-          }
-        });
       });
 
+      // 统一的卡片点击处理
+      function initCardSelection() {
+        const cards = document.querySelectorAll('.mcp-card');
+        cards.forEach((card) => {
+          card.addEventListener('click', function(e) {
+            // 如果点击的是操作按钮区域，不处理选中逻辑
+            if (e.target.closest('.mcp-actions')) {
+              e.stopPropagation();
+              return;
+            }
+            // 移除所有选中状态
+            document.querySelectorAll('.mcp-card.selected').forEach(c => c.classList.remove('selected'));
+            // 添加当前卡片选中状态
+            this.classList.add('selected');
+            // 调用选中处理函数
+            onCardSelected(this);
+          });
+        });
+      }
+      
+      // 页面加载完成后初始化
+      function initPage() {
+        initCardSelection();
+        
+        // 自动选中第一个在线的服务器卡片
+        const onlineCard = document.querySelector('.mcp-card .status-online')?.closest('.mcp-card');
+        const firstCard = document.querySelector('.mcp-card');
+        
+        if (onlineCard) {
+          onlineCard.classList.add('selected');
+          onCardSelected(onlineCard);
+        } else if (firstCard) {
+          // 如果没有在线的，选中第一个卡片
+          firstCard.classList.add('selected');
+          onCardSelected(firstCard);
+        }
+      }
+      
+      if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', initPage);
+      } else {
+        initPage();
+      }
+
+      function onCardSelected(card) {
+        const infoPanel = document.querySelector('.mcp-info-panel');
+        if (!infoPanel) return;
+        
+        infoPanel.classList.add('active');
+        const serverId = card.getAttribute('data-server-id');
+        const nameNode = card.querySelector('.mcp-title');
+        const ipNode = card.querySelector('.mcp-info:nth-child(2) .mcp-value');
+        const latencyNode = card.querySelector('.mcp-info:nth-child(3) .mcp-value');
+        const connectionTimeNode = card.querySelector('.mcp-info:nth-child(4) .mcp-value');
+        const statusDiv = card.querySelector('.status-online, .status-offline');
+        const transport = card.getAttribute('data-transport') || 'sse';
+
+        const server = {
+          name: nameNode ? nameNode.textContent : '--',
+          ip: ipNode ? (ipNode.getAttribute('data-full-ip') || ipNode.textContent) : '--',
+          latency: latencyNode ? latencyNode.textContent : '--',
+          connectionTime: connectionTimeNode ? connectionTimeNode.textContent : '--',
+          transport: transport
+        };
+
+        // 更新面板基础信息
+        const ipValue = infoPanel.querySelector('.mcp-info-item:nth-child(1) .mcp-info-value');
+        const typeValue = infoPanel.querySelector('.mcp-info-item:nth-child(2) .mcp-info-value');
+        const latencyValue = infoPanel.querySelector('.mcp-info-item:nth-child(3) .mcp-info-value');
+        const toolsValue = infoPanel.querySelector('.mcp-info-item:nth-child(4) .mcp-info-value');
+        
+        if (ipValue) { 
+          ipValue.textContent = truncateText(server.ip); 
+          ipValue.title = server.ip; 
+        }
+        if (typeValue) {
+          typeValue.textContent = transport === 'stdio' ? 'STDIO（本地）' : 'SSE（远程）';
+        }
+        if (latencyValue) { 
+          latencyValue.textContent = server.latency; 
+        }
+        const toolsContainer = document.getElementById('toolsContainer');
+        if (toolsContainer) { 
+          toolsContainer.innerHTML = '<span style="color: #909399;">加载中...</span>'; 
+        }
+
+        // 检查是否在线
+        const isOnline = statusDiv && statusDiv.classList.contains('status-online');
+        if (!isOnline) {
+          const toolsContainer = document.getElementById('toolsContainer');
+          if (toolsContainer) {
+            toolsContainer.innerHTML = '<span style="color: #909399;">服务器离线（点击"连接"按钮后可查看工具）</span>';
+          }
+          return;
+        }
+
+        // 加载工具列表
+        fetch(`/api/mcp/servers/${serverId}/tools`)
+          .then(response => {
+            if (!response.ok) {
+              throw new Error('Failed to fetch tools');
+            }
+            return response.json();
+          })
+          .then(data => {
+            console.log('工具数据:', data); // 调试信息
+            const toolsContainer = document.getElementById('toolsContainer');
+            if (toolsContainer) {
+              toolsContainer.innerHTML = '';
+              const tools = data.tools || [];
+              
+              if (tools.length > 0) {
+                tools.forEach(tool => {
+                  console.log('工具对象:', tool); // 调试信息
+                  let toolName = '';
+                  let toolEnabled = true; // 默认启用
+                  
+                  if (typeof tool === 'object' && tool !== null) {
+                    toolName = tool.name || '未知工具';
+                    // 如果后端返回了启用状态，使用它
+                    if (typeof tool.enabled !== 'undefined') {
+                      toolEnabled = tool.enabled;
+                      console.log(`工具 ${toolName} 状态:`, toolEnabled); // 调试信息
+                    }
+                  } else if (typeof tool === 'string') {
+                    toolName = tool;
+                  } else {
+                    toolName = '未知工具';
+                  }
+                  
+                  // 创建工具按钮
+                  const toolBtn = document.createElement('div');
+                  toolBtn.className = `tool-btn ${toolEnabled ? 'enabled' : ''}`;
+                  toolBtn.innerHTML = `
+                    <span class="tool-status-dot"></span>
+                    <span>${toolName}</span>
+                  `;
+                  toolBtn.title = `点击${toolEnabled ? '禁用' : '启用'}工具: ${toolName}`;
+                  toolBtn.dataset.toolName = toolName;
+                  toolBtn.dataset.serverId = serverId;
+                  toolBtn.dataset.enabled = toolEnabled;
+                  
+                  // 添加点击事件
+                  toolBtn.addEventListener('click', function() {
+                    toggleTool(this, serverId, toolName);
+                  });
+                  
+                  toolsContainer.appendChild(toolBtn);
+                });
+              } else {
+                toolsContainer.innerHTML = '<span style="color: #909399;">无可用工具</span>';
+              }
+            }
+          })
+          .catch(err => {
+            console.error('获取工具列表失败:', err);
+            const toolsContainer = document.getElementById('toolsContainer');
+            if (toolsContainer) {
+              toolsContainer.innerHTML = '<span style="color: #f56c6c;">获取工具列表失败</span>';
+            }
+          });
+      }
+
       // 更新信息面板
       function updateInfoPanel(server, toolsInfo) {
         const infoPanel = document.querySelector('.mcp-info-panel');
@@ -949,7 +1171,7 @@
         
         const ipValue = infoPanel.querySelector('.mcp-info-item:nth-child(1) .mcp-info-value');
         const latencyValue = infoPanel.querySelector('.mcp-info-item:nth-child(3) .mcp-info-value');
-        const toolsValue = infoPanel.querySelector('.mcp-info-item:nth-child(4) .mcp-info-value');
+        const toolsContainer = document.getElementById('toolsContainer');
         
         if (ipValue && server && server.ip) {
           ipValue.textContent = truncateText(server.ip);
@@ -960,14 +1182,62 @@
           latencyValue.textContent = server.latency;
         }
         
-        if (toolsValue && toolsInfo) {
-          toolsValue.textContent = toolsInfo;
+        if (toolsContainer && toolsInfo) {
+          // 简单显示工具信息文本，连接成功后会由onCardSelected更新为按钮
+          toolsContainer.innerHTML = `<span style="color: #303133;">${toolsInfo}</span>`;
         }
         
         // 显示信息面板
         infoPanel.classList.add('active');
       }
 
+      // 切换工具状态
+      function toggleTool(btn, serverId, toolName) {
+        const isEnabled = btn.dataset.enabled === 'true';
+        const newState = !isEnabled;
+        
+        // 立即更新UI
+        btn.dataset.enabled = newState;
+        if (newState) {
+          btn.classList.add('enabled');
+          btn.title = `点击禁用工具: ${toolName}`;
+        } else {
+          btn.classList.remove('enabled');
+          btn.title = `点击启用工具: ${toolName}`;
+        }
+        
+        // 发送API请求更新状态
+        fetch(`/api/mcp/servers/${serverId}/tools/${encodeURIComponent(toolName)}/toggle`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify({ enabled: newState })
+        })
+        .then(response => {
+          if (!response.ok) {
+            throw new Error('Failed to toggle tool state');
+          }
+          return response.json();
+        })
+        .then(data => {
+          console.log(`工具 ${toolName} 已${newState ? '启用' : '禁用'}`);
+        })
+        .catch(err => {
+          console.error('切换工具状态失败:', err);
+          // 恢复原状态
+          btn.dataset.enabled = isEnabled;
+          if (isEnabled) {
+            btn.classList.add('enabled');
+            btn.title = `点击禁用工具: ${toolName}`;
+          } else {
+            btn.classList.remove('enabled');
+            btn.title = `点击启用工具: ${toolName}`;
+          }
+          alert(`切换工具状态失败: ${err.message}`);
+        });
+      }
+      
       // 初始化Vue实例
       new Vue({
         el: '#app',
diff --git a/gui/flask_server.py b/gui/flask_server.py
index d87ff1c..baa3dbf 100644
--- a/gui/flask_server.py
+++ b/gui/flask_server.py
@@ -459,7 +459,7 @@ def non_streaming_response(last_content, username):
         text += sentence.replace("_<isfirst>", "").replace("_<isend>", "")
         if is_end:
             if username in fay_booter.feiFei.nlp_streams:
-                stream_manager.new_instance().clear_Stream(username)
+                stream_manager.new_instance().clear_Stream(username) 
             break
     return jsonify({
         "id": "fay-" + str(uuid.uuid4()),
@@ -562,6 +562,8 @@ def to_stop_talking():
         username = data.get('username', 'User')
         message = data.get('text', '你好，请说？')
         observation = data.get('observation', '')
+        from queue import Queue
+        stream_manager.clear_Stream_with_audio(username)
         interact = Interact("stop_talking", 2, {'user': username, 'text': message, 'observation': str(observation)})
         result = fay_booter.feiFei.on_interact(interact)
         return jsonify({
diff --git a/gui/static/images/Logo.png b/gui/static/images/Logo.png
index 903bd16..7f1a541 100644
Binary files a/gui/static/images/Logo.png and b/gui/static/images/Logo.png differ
diff --git a/gui/window.py b/gui/window.py
index 76a9d6c..69462b6 100644
--- a/gui/window.py
+++ b/gui/window.py
@@ -34,13 +34,19 @@ class MainWindow(QMainWindow):
     def runnable(self):
         while True:
             if not self.isVisible():
-                # try:
-                #     wsa_server.get_instance().stop_server()
-                #     wsa_server.get_web_instance().stop_server()
-                #     thread_manager.stopAll()
-                # except BaseException as e:
-                #     print(e)
-                os.system("taskkill /F /PID {}".format(os.getpid()))
+                try:
+                    # 正常关闭服务
+                    import fay_booter
+                    if fay_booter.is_running():
+                        print("窗口关闭，正在停止Fay服务...")
+                        fay_booter.stop()
+                        time.sleep(0.5)  # 给服务一点时间完成清理
+                    print("服务已停止")
+                except BaseException as e:
+                    print(f"正常关闭服务时出错: {e}")
+                finally:
+                    # 如果正常关闭失败，再强制终止
+                    os.system("taskkill /F /PID {}".format(os.getpid()))
             time.sleep(0.05)
 
     def center(self):
diff --git a/llm/nlp_cognitive_stream.py b/llm/nlp_cognitive_stream.py
index 2e2b571..21f78e2 100644
--- a/llm/nlp_cognitive_stream.py
+++ b/llm/nlp_cognitive_stream.py
@@ -43,7 +43,7 @@ from core import stream_manager
 os.environ["LANGCHAIN_TRACING_V2"] = "true"
 os.environ["LANGCHAIN_ENDPOINT"] = "https://api.smith.langchain.com"
 os.environ["LANGCHAIN_API_KEY"] = "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"
-os.environ["LANGCHAIN_PROJECT"] = "fay3.1.2_github"
+os.environ["LANGCHAIN_PROJECT"] = "fay3.8.2_github"
 
 # 加载配置
 cfg.load_config()
@@ -818,7 +818,7 @@ def question(content, username, observation=None):
     # 2. 存在mcp工具，走react agent
     if mcp_tools:
 
-        is_agent_think_start = False
+        is_agent_think_start = False#记录是否已经写入start标签
         #2.1 构建react agent
         tools = [_build_tool(t) for t in mcp_tools] if mcp_tools else []
         react_agent = create_react_agent(llm, tools)
@@ -830,7 +830,7 @@ def question(content, username, observation=None):
         for chunk in react_agent.stream(
                     {"messages": messages}, {"configurable": {"thread_id": "tid{}".format(username)}}
                 ):
-            react_response_text = ""
+            react_response_text = ""           
             # 消息类型1：检测工具调用开始
             if "agent" in chunk and "tool_calls" in str(chunk):
                 try:
@@ -845,6 +845,8 @@ def question(content, username, observation=None):
                         if is_first_sentence:
                             content_temp = react_response_text + "_<isfirst>"
                             is_first_sentence = False
+                        else:
+                            content_temp = react_response_text
 
                         stream_manager.new_instance().write_sentence(username, content_temp)
                 except (KeyError, IndexError, AttributeError) as e:
@@ -1065,9 +1067,14 @@ def perform_daily_reflection():
         
         # 执行反思，传入当前时间戳
         for username, agent in agents.items():
-            # 获取当前时间作为time_step
-            current_time_step = get_current_time_step(username)
-            agent.reflect(topic, time_step=current_time_step)
+            try:
+                # 获取当前时间作为time_step
+                current_time_step = get_current_time_step(username)
+                agent.reflect(topic, time_step=current_time_step)
+            except KeyError as e:
+                util.log(1, f"反思时出现KeyError: {e}，跳过此次反思")
+            except Exception as e:
+                util.log(1, f"反思时出现错误: {e}，跳过此次反思")
         
         # 记录反思执行情况
         util.log(1, f"反思主题: {topic}")
diff --git a/main.py b/main.py
index 0f9e5d8..ce7e663 100644
--- a/main.py
+++ b/main.py
@@ -6,6 +6,9 @@ import time
 import psutil
 import re
 import argparse
+import signal
+import atexit
+import threading
 from utils import config_util, util
 from asr import ali_nls
 from core import wsa_server
@@ -15,6 +18,83 @@ import fay_booter
 from scheduler.thread_manager import MyThread
 from core.interact import Interact
 
+# import sys, io, traceback
+# class StdoutInterceptor(io.TextIOBase):
+#     def __init__(self, orig):
+#         self._orig = orig
+#     def write(self, s):
+#         try:
+#             if s.strip() == "1":
+#                 self._orig.write("[debug] caught raw '1', stack:\n")
+#                 traceback.print_stack(limit=8, file=self._orig)
+#         except Exception:
+#             pass
+#         return self._orig.write(s)
+#     def flush(self): 
+#         return self._orig.flush()
+# sys.stdout = StdoutInterceptor(sys.stdout)
+
+# 程序退出处理
+def cleanup_on_exit():
+    """程序退出时的清理函数"""
+    try:
+        util.log(1, '程序退出，正在清理资源...')
+        if fay_booter.is_running():
+            fay_booter.stop()
+        
+        # 停止所有自定义线程
+        try:
+            from scheduler.thread_manager import stopAll
+            util.log(1, '正在停止所有线程...')
+            stopAll()
+            util.log(1, '所有线程已停止')
+        except Exception as e:
+            util.log(1, f'停止线程时出错: {e}')
+            
+        util.log(1, '资源清理完成')
+    except Exception as e:
+        util.log(1, f'清理资源时出错: {e}')
+
+# 信号处理函数
+def signal_handler(signum, frame):
+    """处理终止信号"""
+    util.log(1, f'收到信号 {signum}，正在退出程序...')
+    
+    # 使用独立线程进行清理，避免信号处理器被阻塞
+    def cleanup_and_exit():
+        try:
+            cleanup_on_exit()
+        except Exception as e:
+            util.log(1, f'清理过程异常: {e}')
+        finally:
+            # 给其他线程一点时间完成清理
+            time.sleep(1.0)
+            
+            # 强制退出，避免被非守护线程阻塞
+            util.log(1, '程序即将强制退出...')
+            os._exit(0)  # 立即退出，不调用atexit处理器
+    
+    # 在单独线程中执行清理，避免阻塞信号处理器
+    cleanup_thread = threading.Thread(target=cleanup_and_exit, daemon=True)
+    cleanup_thread.start()
+    
+    # 如果清理线程超过5秒还没完成，强制退出
+    cleanup_thread.join(timeout=5.0)
+    if cleanup_thread.is_alive():
+        util.log(1, '清理超时，立即强制退出...')
+        os._exit(1)
+
+# 注册退出处理和信号处理
+atexit.register(cleanup_on_exit)
+try:
+    signal.signal(signal.SIGINT, signal_handler)   # Ctrl+C
+    signal.signal(signal.SIGTERM, signal_handler)  # 终止信号
+    # Windows特有信号
+    if hasattr(signal, 'SIGBREAK'):
+        signal.signal(signal.SIGBREAK, signal_handler)
+except Exception as e:
+    util.log(1, f'注册信号处理器失败: {e}')
+
 #载入配置
 config_util.load_config()
 
@@ -38,7 +118,11 @@ def __clear_logs():
         os.mkdir("./logs")
     for file_name in os.listdir('./logs'):
         if file_name.endswith('.log'):
-            os.remove('./logs/' + file_name)        
+            try:
+                os.remove('./logs/' + file_name)
+            except PermissionError:
+                print(f"Warning: Cannot delete {file_name} - file is in use by another process")
+                continue        
 
 def __create_memory():
     if not os.path.exists("./memory"):
diff --git a/mcp_servers/schedule_manager/README.md b/mcp_servers/schedule_manager/README.md
new file mode 100644
index 0000000..9ca45fc
--- /dev/null
+++ b/mcp_servers/schedule_manager/README.md
@@ -0,0 +1,161 @@
+# Fay日程管理MCP Server
+
+基于MCP协议的智能日程管理系统，深度集成Fay数字人助手，提供自然语言日程管理和自动提醒功能。
+
+## 核心功能
+
+### 📅 日程管理
+- **智能解析**：自然语言输入，如"明天上午提醒我开会"
+- **灵活调度**：支持单次和周期性任务
+- **状态管理**：活跃、完成、删除状态跟踪
+- **多用户支持**：基于UID的用户隔离
+
+### 🌐 Web管理界面
+- **自动启动**：连接MCP时自动开启Web界面（http://localhost:5011）
+- **可视化管理**：卡片式日程展示，支持增删改查
+- **高级筛选**：按状态、日期、关键词筛选
+- **响应式设计**：支持PC和移动端访问
+
+### 🤖 Fay集成
+- **语音提醒**：到时自动通过Fay播报提醒
+- **智能交互**：支持语音和文字双向沟通
+- **无缝集成**：原生支持Fay的文字沟通接口
+
+## 快速开始
+
+### 1. 安装依赖
+
+```bash
+pip install mcp flask flask-cors
+```
+
+### 2. 配置Fay
+
+在Fay的MCP管理界面添加：
+- **名称**: Fay日程管理
+- **类型**: STDIO（本地）
+- **命令**: python
+- **参数**: server.py
+- **工作目录**: mcp_servers/schedule_manager
+
+### 3. 使用方式
+
+#### 通过Fay语音交互
+- "明天上午9点提醒我开会"
+- "查看今天的日程"
+- "取消下午3点的会议"
+
+#### 通过Web界面管理
+连接MCP后访问 http://localhost:5011
+
+## MCP工具说明
+
+### parse_natural_schedule
+解析自然语言日程指令
+
+**示例输入**：
+- "明天上午提醒我开会" → 标题："开会"，时间："明天 09:00"
+- "10分钟后提醒我休息" → 标题："休息"，时间："当前时间+10分钟"
+
+### add_schedule
+添加日程任务
+
+**参数**：
+- `title`: 日程标题
+- `content`: 详细内容
+- `schedule_time`: 执行时间（YYYY-MM-DD HH:MM）
+- `repeat_rule`: 重复规则（7位数字，1=重复，0=不重复）
+- `uid`: 用户ID
+
+### get_schedules
+获取日程列表
+
+**参数**：
+- `status`: 状态筛选（active/completed/deleted）
+- `uid`: 用户ID筛选
+
+### update_schedule
+更新日程信息
+
+### delete_schedule
+删除日程（软删除）
+
+### send_message_to_fay
+直接发送消息给Fay
+
+## 技术架构
+
+```
+┌─────────────┐     ┌──────────┐     ┌───────────┐
+│   Fay主程序  │────▶│ MCP Server│────▶│  Web界面   │
+└─────────────┘     └──────────┘     └───────────┘
+       │                  │                 │
+       └──────────────────┴─────────────────┘
+                          │
+                    ┌──────────┐
+                    │  SQLite   │
+                    └──────────┘
+```
+
+## 数据存储
+
+使用SQLite数据库（schedules.db）存储日程：
+
+| 字段 | 类型 | 说明 |
+|-----|------|-----|
+| id | INTEGER | 主键 |
+| title | TEXT | 标题 |
+| content | TEXT | 内容 |
+| schedule_time | TEXT | 执行时间 |
+| repeat_rule | TEXT | 重复规则 |
+| status | TEXT | 状态 |
+| uid | INTEGER | 用户ID |
+
+## 重复规则说明
+
+7位数字字符串，每位代表周一到周日：
+- `0000000`: 单次执行
+- `1111100`: 工作日重复
+- `1111111`: 每日重复
+- `1000100`: 周一和周五重复
+
+## 注意事项
+
+1. **端口占用**：Web界面使用5011端口，确保未被占用
+2. **时区设置**：使用系统本地时区
+3. **进程管理**：断开MCP连接时Web服务器自动关闭
+4. **数据安全**：日程数据存储在本地，注意备份
+
+## 故障排除
+
+### Web界面无法访问
+- 检查5011端口是否被占用
+- 确认MCP服务器已连接
+- 查看日志确认Web服务器已启动
+
+### 提醒未触发
+- 检查日程时间设置是否正确
+- 确认Fay主程序正在运行
+- 查看日程状态是否为active
+
+### 自然语言解析错误
+- 使用更明确的时间表述
+- 避免过于复杂的句式
+- 参考示例格式输入
+
+## 更新日志
+
+### v1.2.0 (2025-08-23)
+- 新增自然语言解析功能
+- 集成Web管理界面
+- 优化进程生命周期管理
+- 修复重复提醒问题
+
+### v1.0.0
+- 基础日程管理功能
+- MCP协议支持
+- Fay集成
+
+## 许可证
+
+MIT License
\ No newline at end of file
diff --git a/mcp_servers/schedule_manager/requirements.txt b/mcp_servers/schedule_manager/requirements.txt
new file mode 100644
index 0000000..6ca3fd0
--- /dev/null
+++ b/mcp_servers/schedule_manager/requirements.txt
@@ -0,0 +1,2 @@
+mcp>=1.0.0
+sqlite3
\ No newline at end of file
diff --git a/mcp_servers/schedule_manager/schedule_web.html b/mcp_servers/schedule_manager/schedule_web.html
new file mode 100644
index 0000000..f0e022a
--- /dev/null
+++ b/mcp_servers/schedule_manager/schedule_web.html
@@ -0,0 +1,897 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Fay日程管理</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Microsoft YaHei', Arial, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            padding: 20px;
+        }
+
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            background: white;
+            border-radius: 12px;
+            box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
+            overflow: hidden;
+        }
+
+        .header {
+            background: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
+            color: white;
+            padding: 30px;
+            text-align: center;
+        }
+
+        .header h1 {
+            font-size: 32px;
+            margin-bottom: 10px;
+        }
+
+        .header p {
+            font-size: 16px;
+            opacity: 0.9;
+        }
+
+        .main-content {
+            display: flex;
+            min-height: 600px;
+        }
+
+        .sidebar {
+            width: 300px;
+            background: #f8f9fa;
+            padding: 30px;
+            border-right: 1px solid #eee;
+        }
+
+        .add-schedule-btn {
+            width: 100%;
+            padding: 15px;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            border: none;
+            border-radius: 8px;
+            font-size: 16px;
+            cursor: pointer;
+            margin-bottom: 30px;
+            transition: all 0.3s ease;
+        }
+
+        .add-schedule-btn:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 4px 12px rgba(102, 126, 234, 0.4);
+        }
+
+        .filter-section {
+            margin-bottom: 20px;
+        }
+
+        .filter-title {
+            font-size: 18px;
+            margin-bottom: 15px;
+            color: #333;
+        }
+
+        .filter-group {
+            margin-bottom: 15px;
+        }
+
+        .filter-group label {
+            display: block;
+            margin-bottom: 5px;
+            color: #666;
+            font-size: 14px;
+        }
+
+        .filter-input {
+            width: 100%;
+            padding: 10px;
+            border: 2px solid #e0e0e0;
+            border-radius: 6px;
+            font-size: 14px;
+            transition: border-color 0.3s ease;
+        }
+
+        .filter-input:focus {
+            border-color: #667eea;
+            outline: none;
+        }
+
+        .content-area {
+            flex: 1;
+            padding: 30px;
+        }
+
+        .schedule-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+            gap: 20px;
+        }
+
+        .schedule-card {
+            background: white;
+            border-radius: 10px;
+            padding: 20px;
+            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+            border-left: 4px solid #667eea;
+            transition: all 0.3s ease;
+            cursor: pointer;
+        }
+
+        .schedule-card:hover {
+            transform: translateY(-4px);
+            box-shadow: 0 8px 24px rgba(0, 0, 0, 0.15);
+        }
+
+        .schedule-card.today {
+            border-left-color: #ff6b6b;
+            background: linear-gradient(135deg, rgba(255, 107, 107, 0.05) 0%, rgba(255, 107, 107, 0.02) 100%);
+        }
+
+        .schedule-card.completed {
+            opacity: 0.6;
+            border-left-color: #51cf66;
+        }
+
+        .card-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: flex-start;
+            margin-bottom: 15px;
+        }
+
+        .card-title {
+            font-size: 18px;
+            font-weight: 600;
+            color: #333;
+            margin-bottom: 5px;
+        }
+
+        .card-time {
+            font-size: 14px;
+            color: #667eea;
+            font-weight: 500;
+        }
+
+        .card-status {
+            padding: 4px 12px;
+            border-radius: 12px;
+            font-size: 12px;
+            font-weight: 500;
+        }
+
+        .status-active {
+            background: rgba(102, 126, 234, 0.1);
+            color: #667eea;
+        }
+
+        .status-completed {
+            background: rgba(81, 207, 102, 0.1);
+            color: #51cf66;
+        }
+
+        .card-content {
+            font-size: 14px;
+            color: #666;
+            line-height: 1.6;
+            margin-bottom: 15px;
+        }
+
+        .card-repeat {
+            font-size: 12px;
+            color: #999;
+            margin-bottom: 15px;
+        }
+
+        .card-actions {
+            display: flex;
+            gap: 10px;
+        }
+
+        .btn {
+            padding: 8px 16px;
+            border: none;
+            border-radius: 6px;
+            cursor: pointer;
+            font-size: 12px;
+            transition: all 0.3s ease;
+        }
+
+        .btn-edit {
+            background: #4ecdc4;
+            color: white;
+        }
+
+        .btn-delete {
+            background: #ff6b6b;
+            color: white;
+        }
+
+        .btn-complete {
+            background: #51cf66;
+            color: white;
+        }
+
+        .btn:hover {
+            transform: translateY(-1px);
+            box-shadow: 0 2px 8px rgba(0, 0, 0, 0.2);
+        }
+
+        .modal {
+            display: none;
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background: rgba(0, 0, 0, 0.5);
+            z-index: 1000;
+        }
+
+        .modal-content {
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            background: white;
+            padding: 30px;
+            border-radius: 12px;
+            width: 90%;
+            max-width: 500px;
+            max-height: 80vh;
+            overflow-y: auto;
+        }
+
+        .modal-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 30px;
+            padding-bottom: 15px;
+            border-bottom: 2px solid #f0f0f0;
+        }
+
+        .modal-title {
+            font-size: 24px;
+            color: #333;
+        }
+
+        .close-btn {
+            background: none;
+            border: none;
+            font-size: 24px;
+            cursor: pointer;
+            color: #999;
+        }
+
+        .form-group {
+            margin-bottom: 20px;
+        }
+
+        .form-label {
+            display: block;
+            margin-bottom: 8px;
+            font-weight: 600;
+            color: #333;
+        }
+
+        .form-input {
+            width: 100%;
+            padding: 12px;
+            border: 2px solid #e0e0e0;
+            border-radius: 8px;
+            font-size: 16px;
+            transition: border-color 0.3s ease;
+        }
+
+        .form-input:focus {
+            border-color: #667eea;
+            outline: none;
+        }
+
+        .form-textarea {
+            min-height: 100px;
+            resize: vertical;
+        }
+
+        .repeat-days {
+            display: grid;
+            grid-template-columns: repeat(7, 1fr);
+            gap: 8px;
+            margin-top: 10px;
+        }
+
+        .day-btn {
+            padding: 8px;
+            border: 2px solid #e0e0e0;
+            background: white;
+            border-radius: 6px;
+            cursor: pointer;
+            transition: all 0.3s ease;
+            text-align: center;
+            font-size: 12px;
+        }
+
+        .day-btn.active {
+            background: #667eea;
+            color: white;
+            border-color: #667eea;
+        }
+
+        .modal-actions {
+            display: flex;
+            justify-content: flex-end;
+            gap: 15px;
+            margin-top: 30px;
+            padding-top: 20px;
+            border-top: 2px solid #f0f0f0;
+        }
+
+        .btn-primary {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 12px 24px;
+            border: none;
+            border-radius: 8px;
+            cursor: pointer;
+            font-size: 16px;
+            transition: all 0.3s ease;
+        }
+
+        .btn-secondary {
+            background: #f8f9fa;
+            color: #666;
+            padding: 12px 24px;
+            border: 2px solid #e0e0e0;
+            border-radius: 8px;
+            cursor: pointer;
+            font-size: 16px;
+            transition: all 0.3s ease;
+        }
+
+        .btn-primary:hover, .btn-secondary:hover {
+            transform: translateY(-1px);
+            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2);
+        }
+
+        .empty-state {
+            text-align: center;
+            padding: 60px 20px;
+            color: #999;
+        }
+
+        .empty-state h3 {
+            font-size: 24px;
+            margin-bottom: 10px;
+        }
+
+        .empty-state p {
+            font-size: 16px;
+        }
+
+        .loading {
+            text-align: center;
+            padding: 40px;
+            color: #666;
+        }
+
+        .error {
+            text-align: center;
+            padding: 40px;
+            color: #ff6b6b;
+        }
+
+        /* Toast提示样式 */
+        .toast {
+            position: fixed;
+            top: 20px;
+            right: 20px;
+            padding: 15px 20px;
+            background: #51cf66;
+            color: white;
+            border-radius: 8px;
+            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+            z-index: 2000;
+            opacity: 0;
+            transform: translateX(100%);
+            transition: all 0.3s ease;
+        }
+
+        .toast.show {
+            opacity: 1;
+            transform: translateX(0);
+        }
+
+        .toast.error {
+            background: #ff6b6b;
+        }
+
+        .toast.warning {
+            background: #ffd43b;
+            color: #333;
+        }
+
+        @media (max-width: 768px) {
+            .main-content {
+                flex-direction: column;
+            }
+
+            .sidebar {
+                width: 100%;
+                padding: 20px;
+            }
+
+            .schedule-grid {
+                grid-template-columns: 1fr;
+            }
+
+            .modal-content {
+                width: 95%;
+                padding: 20px;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>📅 Fay日程管理</h1>
+            <p>智能助手的日程安排与提醒系统</p>
+        </div>
+
+        <div class="main-content">
+            <div class="sidebar">
+                <button class="add-schedule-btn" onclick="showAddModal()">
+                    ➕ 添加新日程
+                </button>
+
+                <div class="filter-section">
+                    <div class="filter-title">筛选条件</div>
+                    
+                    <div class="filter-group">
+                        <label>状态</label>
+                        <select class="filter-input" id="statusFilter" onchange="filterSchedules()">
+                            <option value="all">全部</option>
+                            <option value="active">活跃</option>
+                            <option value="completed">已完成</option>
+                        </select>
+                    </div>
+
+                    <div class="filter-group">
+                        <label>搜索关键词</label>
+                        <input type="text" class="filter-input" id="searchInput" placeholder="搜索标题或内容..." oninput="filterSchedules()">
+                    </div>
+
+                    <div class="filter-group">
+                        <label>日期范围</label>
+                        <input type="date" class="filter-input" id="dateFrom" onchange="filterSchedules()">
+                        <input type="date" class="filter-input" id="dateTo" onchange="filterSchedules()" style="margin-top: 8px;">
+                    </div>
+                </div>
+            </div>
+
+            <div class="content-area">
+                <div id="scheduleContainer" class="schedule-grid">
+                    <div class="loading">正在加载日程...</div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- 添加/编辑日程模态框 -->
+    <div id="scheduleModal" class="modal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h2 class="modal-title" id="modalTitle">添加新日程</h2>
+                <button class="close-btn" onclick="hideModal()">&times;</button>
+            </div>
+
+            <form id="scheduleForm">
+                <input type="hidden" id="scheduleId">
+                
+                <div class="form-group">
+                    <label class="form-label">日程标题 *</label>
+                    <input type="text" id="scheduleTitle" class="form-input" placeholder="请输入日程标题" required>
+                </div>
+
+                <div class="form-group">
+                    <label class="form-label">详细内容</label>
+                    <textarea id="scheduleContent" class="form-input form-textarea" placeholder="请输入详细内容..."></textarea>
+                </div>
+
+                <div class="form-group">
+                    <label class="form-label">执行时间 *</label>
+                    <input type="datetime-local" id="scheduleTime" class="form-input" required>
+                </div>
+
+                <div class="form-group">
+                    <label class="form-label">重复设置</label>
+                    <div class="repeat-days">
+                        <button type="button" class="day-btn" data-day="0" onclick="toggleDay(this)">一</button>
+                        <button type="button" class="day-btn" data-day="1" onclick="toggleDay(this)">二</button>
+                        <button type="button" class="day-btn" data-day="2" onclick="toggleDay(this)">三</button>
+                        <button type="button" class="day-btn" data-day="3" onclick="toggleDay(this)">四</button>
+                        <button type="button" class="day-btn" data-day="4" onclick="toggleDay(this)">五</button>
+                        <button type="button" class="day-btn" data-day="5" onclick="toggleDay(this)">六</button>
+                        <button type="button" class="day-btn" data-day="6" onclick="toggleDay(this)">日</button>
+                    </div>
+                    <small style="color: #999; margin-top: 8px; display: block;">选择重复的日期，不选择表示只执行一次</small>
+                </div>
+
+                <div class="modal-actions">
+                    <button type="button" class="btn-secondary" onclick="hideModal()">取消</button>
+                    <button type="submit" class="btn-primary">保存</button>
+                </div>
+            </form>
+        </div>
+    </div>
+
+    <script>
+        let schedules = [];
+        let currentEditId = null;
+
+        // Toast提示函数
+        function showToast(message, type = 'success') {
+            // 移除已存在的toast
+            const existingToast = document.querySelector('.toast');
+            if (existingToast) {
+                existingToast.remove();
+            }
+
+            // 创建新的toast
+            const toast = document.createElement('div');
+            toast.className = `toast ${type}`;
+            toast.textContent = message;
+            document.body.appendChild(toast);
+
+            // 显示toast
+            setTimeout(() => toast.classList.add('show'), 10);
+
+            // 3秒后自动隐藏
+            setTimeout(() => {
+                toast.classList.remove('show');
+                setTimeout(() => toast.remove(), 300);
+            }, 3000);
+        }
+
+        // 页面加载完成后初始化
+        document.addEventListener('DOMContentLoaded', function() {
+            loadSchedules();
+            
+            // 设置表单提交事件
+            document.getElementById('scheduleForm').addEventListener('submit', function(e) {
+                e.preventDefault();
+                saveSchedule();
+            });
+        });
+
+        // 加载日程列表
+        async function loadSchedules() {
+            try {
+                const response = await fetch('/api/schedule/list');
+                if (!response.ok) {
+                    throw new Error('获取日程列表失败');
+                }
+                const data = await response.json();
+                schedules = data.schedules || [];
+                renderSchedules();
+            } catch (error) {
+                console.error('加载日程失败:', error);
+                document.getElementById('scheduleContainer').innerHTML = 
+                    '<div class="error">加载日程失败，请刷新页面重试</div>';
+            }
+        }
+
+        // 渲染日程列表
+        function renderSchedules(filteredSchedules = null) {
+            const container = document.getElementById('scheduleContainer');
+            const schedulesToRender = filteredSchedules || schedules;
+
+            if (schedulesToRender.length === 0) {
+                container.innerHTML = `
+                    <div class="empty-state">
+                        <h3>暂无日程</h3>
+                        <p>点击"添加新日程"开始创建您的第一个日程</p>
+                    </div>
+                `;
+                return;
+            }
+
+            container.innerHTML = schedulesToRender.map(schedule => {
+                const scheduleDate = new Date(schedule.schedule_time);
+                const today = new Date();
+                const isToday = scheduleDate.toDateString() === today.toDateString();
+                const isCompleted = schedule.status === 'completed';
+                
+                const repeatText = getRepeatText(schedule.repeat_rule);
+                
+                return `
+                    <div class="schedule-card ${isToday ? 'today' : ''} ${isCompleted ? 'completed' : ''}" 
+                         onclick="editSchedule(${schedule.id})">
+                        <div class="card-header">
+                            <div>
+                                <div class="card-title">${schedule.title}</div>
+                                <div class="card-time">${formatDateTime(schedule.schedule_time)}</div>
+                            </div>
+                            <div class="card-status status-${schedule.status}">
+                                ${schedule.status === 'active' ? '活跃' : '已完成'}
+                            </div>
+                        </div>
+                        <div class="card-content">${schedule.content}</div>
+                        <div class="card-repeat">${repeatText}</div>
+                        <div class="card-actions" onclick="event.stopPropagation()">
+                            <button class="btn btn-edit" onclick="editSchedule(${schedule.id})">编辑</button>
+                            ${schedule.status === 'active' && schedule.repeat_rule === '0000000' ? 
+                                `<button class="btn btn-complete" onclick="completeSchedule(${schedule.id})">完成</button>` : ''
+                            }
+                            <button class="btn btn-delete" onclick="deleteSchedule(${schedule.id})">删除</button>
+                        </div>
+                    </div>
+                `;
+            }).join('');
+        }
+
+        // 筛选日程
+        function filterSchedules() {
+            const statusFilter = document.getElementById('statusFilter').value;
+            const searchInput = document.getElementById('searchInput').value.toLowerCase();
+            const dateFrom = document.getElementById('dateFrom').value;
+            const dateTo = document.getElementById('dateTo').value;
+
+            let filtered = schedules.filter(schedule => {
+                // 状态筛选
+                if (statusFilter !== 'all' && schedule.status !== statusFilter) {
+                    return false;
+                }
+
+                // 搜索筛选
+                if (searchInput && 
+                    !schedule.title.toLowerCase().includes(searchInput) && 
+                    !schedule.content.toLowerCase().includes(searchInput)) {
+                    return false;
+                }
+
+                // 日期范围筛选
+                const scheduleDate = new Date(schedule.schedule_time);
+                if (dateFrom && scheduleDate < new Date(dateFrom)) {
+                    return false;
+                }
+                if (dateTo && scheduleDate > new Date(dateTo + ' 23:59:59')) {
+                    return false;
+                }
+
+                return true;
+            });
+
+            renderSchedules(filtered);
+        }
+
+        // 显示添加模态框
+        function showAddModal() {
+            document.getElementById('modalTitle').textContent = '添加新日程';
+            document.getElementById('scheduleForm').reset();
+            document.getElementById('scheduleId').value = '';
+            currentEditId = null;
+            
+            // 清除重复日期选择
+            document.querySelectorAll('.day-btn').forEach(btn => {
+                btn.classList.remove('active');
+            });
+            
+            document.getElementById('scheduleModal').style.display = 'block';
+        }
+
+        // 编辑日程
+        function editSchedule(id) {
+            const schedule = schedules.find(s => s.id === id);
+            if (!schedule) return;
+
+            document.getElementById('modalTitle').textContent = '编辑日程';
+            document.getElementById('scheduleId').value = schedule.id;
+            document.getElementById('scheduleTitle').value = schedule.title;
+            document.getElementById('scheduleContent').value = schedule.content;
+            
+            // 格式化时间为datetime-local格式
+            const date = new Date(schedule.schedule_time);
+            const formattedDate = date.getFullYear() + '-' + 
+                String(date.getMonth() + 1).padStart(2, '0') + '-' + 
+                String(date.getDate()).padStart(2, '0') + 'T' + 
+                String(date.getHours()).padStart(2, '0') + ':' + 
+                String(date.getMinutes()).padStart(2, '0');
+            document.getElementById('scheduleTime').value = formattedDate;
+            
+            // 设置重复日期
+            document.querySelectorAll('.day-btn').forEach((btn, index) => {
+                if (schedule.repeat_rule[index] === '1') {
+                    btn.classList.add('active');
+                } else {
+                    btn.classList.remove('active');
+                }
+            });
+            
+            currentEditId = id;
+            document.getElementById('scheduleModal').style.display = 'block';
+        }
+
+        // 保存日程
+        async function saveSchedule() {
+            const id = document.getElementById('scheduleId').value;
+            const title = document.getElementById('scheduleTitle').value;
+            const content = document.getElementById('scheduleContent').value;
+            const scheduleTime = document.getElementById('scheduleTime').value;
+            
+            // 获取重复规则
+            let repeatRule = '0000000';
+            document.querySelectorAll('.day-btn').forEach((btn, index) => {
+                if (btn.classList.contains('active')) {
+                    repeatRule = repeatRule.substring(0, index) + '1' + repeatRule.substring(index + 1);
+                }
+            });
+
+            const scheduleData = {
+                title,
+                content,
+                schedule_time: scheduleTime.replace('T', ' '),
+                repeat_rule: repeatRule
+            };
+
+            try {
+                let response;
+                if (id) {
+                    // 更新
+                    response = await fetch(`/api/schedule/update/${id}`, {
+                        method: 'PUT',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        },
+                        body: JSON.stringify(scheduleData)
+                    });
+                } else {
+                    // 创建
+                    response = await fetch('/api/schedule/create', {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json'
+                        },
+                        body: JSON.stringify(scheduleData)
+                    });
+                }
+
+                if (!response.ok) {
+                    throw new Error('保存日程失败');
+                }
+
+                hideModal();
+                loadSchedules();
+                showToast('日程保存成功');
+            } catch (error) {
+                console.error('保存日程失败:', error);
+                alert('保存日程失败，请重试');
+            }
+        }
+
+        // 完成日程（删除）
+        async function completeSchedule(id) {
+            if (!confirm('确定要完成此日程吗？完成后将自动删除。')) {
+                return;
+            }
+
+            try {
+                const response = await fetch(`/api/schedule/complete/${id}`, {
+                    method: 'PUT'
+                });
+
+                if (!response.ok) {
+                    throw new Error('完成日程失败');
+                }
+
+                loadSchedules();
+                showToast('日程已完成并删除');
+            } catch (error) {
+                console.error('完成日程失败:', error);
+                alert('操作失败，请重试');
+            }
+        }
+
+        // 删除日程
+        async function deleteSchedule(id) {
+            if (!confirm('确定要删除此日程吗？删除后无法恢复。')) {
+                return;
+            }
+
+            try {
+                const response = await fetch(`/api/schedule/delete/${id}`, {
+                    method: 'DELETE'
+                });
+
+                if (!response.ok) {
+                    throw new Error(`删除日程失败，状态码: ${response.status}`);
+                }
+
+                const data = await response.json();
+                if (data.success) {
+                    // 如果删除的是当前正在编辑的日程，关闭模态框
+                    const currentEditId = document.getElementById('scheduleId').value;
+                    if (currentEditId && parseInt(currentEditId) === id) {
+                        hideModal();
+                    }
+                    
+                    // 重新加载日程列表
+                    loadSchedules();
+                    
+                    // 显示成功提示
+                    showToast('日程已成功删除');
+                } else {
+                    throw new Error(data.message || '删除失败');
+                }
+            } catch (error) {
+                console.error('删除日程失败:', error);
+                alert('删除失败：' + error.message);
+            }
+        }
+
+        // 隐藏模态框
+        function hideModal() {
+            document.getElementById('scheduleModal').style.display = 'none';
+        }
+
+        // 切换重复日期
+        function toggleDay(btn) {
+            btn.classList.toggle('active');
+        }
+
+        // 格式化日期时间
+        function formatDateTime(dateTimeStr) {
+            const date = new Date(dateTimeStr);
+            return date.getFullYear() + '-' + 
+                String(date.getMonth() + 1).padStart(2, '0') + '-' + 
+                String(date.getDate()).padStart(2, '0') + ' ' + 
+                String(date.getHours()).padStart(2, '0') + ':' + 
+                String(date.getMinutes()).padStart(2, '0');
+        }
+
+        // 获取重复规则文本
+        function getRepeatText(repeatRule) {
+            if (repeatRule === '0000000') {
+                return '单次执行';
+            }
+
+            const days = ['周一', '周二', '周三', '周四', '周五', '周六', '周日'];
+            const repeatDays = [];
+            for (let i = 0; i < 7; i++) {
+                if (repeatRule[i] === '1') {
+                    repeatDays.push(days[i]);
+                }
+            }
+
+            if (repeatDays.length === 7) {
+                return '每日重复';
+            } else if (repeatDays.length === 5 && !repeatRule.includes('1', 5)) {
+                return '工作日重复';
+            } else {
+                return '重复: ' + repeatDays.join(', ');
+            }
+        }
+
+        // 点击模态框外部关闭
+        window.onclick = function(event) {
+            const modal = document.getElementById('scheduleModal');
+            if (event.target === modal) {
+                hideModal();
+            }
+        }
+    </script>
+</body>
+</html>
\ No newline at end of file
diff --git a/mcp_servers/schedule_manager/schedules.db b/mcp_servers/schedule_manager/schedules.db
new file mode 100644
index 0000000..fce5884
Binary files /dev/null and b/mcp_servers/schedule_manager/schedules.db differ
diff --git a/mcp_servers/schedule_manager/server.py b/mcp_servers/schedule_manager/server.py
new file mode 100644
index 0000000..c74460e
--- /dev/null
+++ b/mcp_servers/schedule_manager/server.py
@@ -0,0 +1,1209 @@
+#!/usr/bin/env python3
+"""
+Fay日程管理MCP Server
+基于agent目录逻辑实现的本地日程管理系统，支持与Fay文字沟通接口集成
+"""
+
+import os
+import sys
+import json
+import sqlite3
+import datetime
+import threading
+import time
+import asyncio
+import logging
+import requests
+import subprocess
+import signal
+import atexit
+import re
+from typing import Any, Dict, List, Optional
+from contextlib import asynccontextmanager
+
+# 添加项目根目录到Python路径
+project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
+sys.path.insert(0, project_root)
+
+try:
+    from mcp.server import Server
+    from mcp.types import Resource, Tool, TextContent, ImageContent, EmbeddedResource
+    import mcp.server.stdio
+    from pydantic import AnyUrl
+except ImportError:
+    print("MCP库未安装，请运行: pip install mcp")
+    sys.exit(1)
+
+# 配置Fay API地址
+FAY_API_URL = "http://127.0.0.1:5000/v1/chat/completions"
+FAY_NOTIFY_URL = "http://127.0.0.1:5000/api/schedule/notify"  # 专用的日程提醒接口
+
+# 配置日志
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger("schedule_manager")
+
+# 数据库文件路径
+DB_PATH = os.path.join(os.path.dirname(__file__), 'schedules.db')
+
+class ScheduleManager:
+    """日程管理核心类"""
+    
+    def __init__(self):
+        self.scheduled_tasks = {}
+        self.task_threads = {}
+        self.executed_tasks = {}  # 记录已执行的任务，防止重复执行
+        self.scheduler_lock_file = os.path.join(os.path.dirname(__file__), '.scheduler.lock')
+        self.scheduler_running = False
+        self.web_server_process = None
+        self.init_database()
+        self.start_scheduler()
+        # 不在初始化时启动Web服务器，而是在MCP连接时启动
+    
+    def init_database(self):
+        """初始化数据库"""
+        conn = sqlite3.connect(DB_PATH)
+        cursor = conn.cursor()
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS schedules (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                title TEXT NOT NULL,
+                content TEXT NOT NULL,
+                schedule_time TEXT NOT NULL,
+                repeat_rule TEXT NOT NULL DEFAULT '0000000',
+                status TEXT NOT NULL DEFAULT 'active',
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL,
+                uid INTEGER DEFAULT 0
+            )
+        ''')
+        conn.commit()
+        conn.close()
+        logger.info("数据库初始化完成")
+    
+    def add_schedule(self, title: str, content: str, schedule_time: str, repeat_rule: str = '0000000', uid: int = 0) -> Dict[str, Any]:
+        """添加日程"""
+        try:
+            # 验证时间格式
+            try:
+                datetime.datetime.strptime(schedule_time, '%Y-%m-%d %H:%M')
+            except ValueError:
+                try:
+                    # 如果只有时间，默认为今天
+                    time_part = datetime.datetime.strptime(schedule_time, '%H:%M').time()
+                    schedule_time = datetime.datetime.combine(datetime.date.today(), time_part).strftime('%Y-%m-%d %H:%M')
+                except ValueError:
+                    return {"success": False, "message": "时间格式错误，请使用 YYYY-MM-DD HH:MM 或 HH:MM 格式"}
+            
+            # 验证重复规则
+            if not all(c in '01' for c in repeat_rule) or len(repeat_rule) != 7:
+                return {"success": False, "message": "重复规则格式错误，应为7位数字，每位代表周一到周日(1=重复,0=不重复)"}
+            
+            now = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            
+            conn = sqlite3.connect(DB_PATH)
+            cursor = conn.cursor()
+            cursor.execute(
+                "INSERT INTO schedules (title, content, schedule_time, repeat_rule, created_at, updated_at, uid) VALUES (?, ?, ?, ?, ?, ?, ?)",
+                (title, content, schedule_time, repeat_rule, now, now, uid)
+            )
+            schedule_id = cursor.lastrowid
+            conn.commit()
+            conn.close()
+            
+            logger.info(f"添加日程成功: {title} - {schedule_time}")
+            return {"success": True, "message": "日程添加成功", "schedule_id": schedule_id}
+            
+        except Exception as e:
+            logger.error(f"添加日程失败: {e}")
+            return {"success": False, "message": f"添加日程失败: {str(e)}"}
+    
+    def get_schedules(self, status: str = 'active', uid: Optional[int] = None) -> List[Dict[str, Any]]:
+        """获取日程列表"""
+        try:
+            conn = sqlite3.connect(DB_PATH)
+            cursor = conn.cursor()
+            
+            if uid is not None:
+                if status == 'all':
+                    # 'all' 表示显示所有未删除的日程（active + completed）
+                    cursor.execute("SELECT * FROM schedules WHERE status != 'deleted' AND uid = ? ORDER BY schedule_time", (uid,))
+                else:
+                    cursor.execute("SELECT * FROM schedules WHERE status = ? AND uid = ? ORDER BY schedule_time", (status, uid))
+            else:
+                if status == 'all':
+                    # 'all' 表示显示所有未删除的日程（active + completed）
+                    cursor.execute("SELECT * FROM schedules WHERE status != 'deleted' ORDER BY schedule_time")
+                else:
+                    cursor.execute("SELECT * FROM schedules WHERE status = ? ORDER BY schedule_time", (status,))
+            
+            rows = cursor.fetchall()
+            conn.close()
+            
+            schedules = []
+            for row in rows:
+                schedules.append({
+                    "id": row[0],
+                    "title": row[1],
+                    "content": row[2],
+                    "schedule_time": row[3],
+                    "repeat_rule": row[4],
+                    "status": row[5],
+                    "created_at": row[6],
+                    "updated_at": row[7],
+                    "uid": row[8]
+                })
+            
+            return schedules
+            
+        except Exception as e:
+            logger.error(f"获取日程列表失败: {e}")
+            return []
+    
+    def update_schedule(self, schedule_id: int, title: Optional[str] = None, content: Optional[str] = None, 
+                       schedule_time: Optional[str] = None, repeat_rule: Optional[str] = None, 
+                       status: Optional[str] = None) -> Dict[str, Any]:
+        """更新日程"""
+        try:
+            conn = sqlite3.connect(DB_PATH)
+            cursor = conn.cursor()
+            
+            # 先获取当前日程信息
+            cursor.execute("SELECT status, repeat_rule FROM schedules WHERE id = ?", (schedule_id,))
+            current_schedule = cursor.fetchone()
+            if not current_schedule:
+                conn.close()
+                return {"success": False, "message": "日程不存在"}
+            
+            current_status, current_repeat_rule = current_schedule
+            
+            # 构建更新语句
+            updates = []
+            params = []
+            auto_activate = False  # 是否需要自动激活
+            
+            if title is not None:
+                updates.append("title = ?")
+                params.append(title)
+            if content is not None:
+                updates.append("content = ?")
+                params.append(content)
+            if schedule_time is not None:
+                # 验证时间格式
+                try:
+                    new_time = datetime.datetime.strptime(schedule_time, '%Y-%m-%d %H:%M')
+                    updates.append("schedule_time = ?")
+                    params.append(schedule_time)
+                    
+                    # 如果更新了时间，并且当前状态是completed，检查是否需要重新激活
+                    if current_status == 'completed':
+                        now = datetime.datetime.now()
+                        # 如果新时间在未来，或者是重复任务，自动激活
+                        if new_time > now or (repeat_rule or current_repeat_rule) != '0000000':
+                            auto_activate = True
+                            logger.info(f"日程 ID {schedule_id} 时间更新，自动从completed恢复为active")
+                            
+                except ValueError:
+                    return {"success": False, "message": "时间格式错误"}
+            if repeat_rule is not None:
+                if not all(c in '01' for c in repeat_rule) or len(repeat_rule) != 7:
+                    return {"success": False, "message": "重复规则格式错误"}
+                updates.append("repeat_rule = ?")
+                params.append(repeat_rule)
+                
+                # 如果从单次改为重复，并且当前是completed，自动激活
+                if current_status == 'completed' and repeat_rule != '0000000':
+                    auto_activate = True
+                    logger.info(f"日程 ID {schedule_id} 改为重复任务，自动从completed恢复为active")
+                    
+            # 处理状态更新
+            if status is not None:
+                updates.append("status = ?")
+                params.append(status)
+            elif auto_activate:
+                # 如果需要自动激活，并且没有明确指定状态，则设置为active
+                updates.append("status = ?")
+                params.append('active')
+                status = 'active'  # 更新status变量以便后续重新调度
+            
+            if not updates:
+                return {"success": False, "message": "没有提供要更新的字段"}
+            
+            updates.append("updated_at = ?")
+            params.append(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
+            params.append(schedule_id)
+            
+            cursor.execute(f"UPDATE schedules SET {', '.join(updates)} WHERE id = ?", params)
+            
+            if cursor.rowcount == 0:
+                conn.close()
+                return {"success": False, "message": "日程不存在"}
+            
+            conn.commit()
+            conn.close()
+            
+            # 如果更新了时间相关字段或状态，需要重新调度定时器
+            if schedule_time is not None or repeat_rule is not None or status is not None or auto_activate:
+                self._reschedule_task(schedule_id)
+            
+            logger.info(f"更新日程成功: ID {schedule_id}")
+            if auto_activate:
+                return {"success": True, "message": "日程更新成功，状态已自动恢复为活跃"}
+            else:
+                return {"success": True, "message": "日程更新成功"}
+            
+        except Exception as e:
+            logger.error(f"更新日程失败: {e}")
+            return {"success": False, "message": f"更新日程失败: {str(e)}"}
+    
+    def delete_schedule(self, schedule_id: int) -> Dict[str, Any]:
+        """删除日程（软删除）"""
+        try:
+            # 先取消定时器和清理执行记录
+            if schedule_id in self.task_threads:
+                if isinstance(self.task_threads[schedule_id], threading.Timer):
+                    self.task_threads[schedule_id].cancel()
+                    logger.info(f"已取消删除任务 ID {schedule_id} 的定时器")
+                del self.task_threads[schedule_id]
+            
+            # 清除执行记录
+            executed_keys_to_remove = [key for key in self.executed_tasks.keys() if key.startswith(f"{schedule_id}_")]
+            for key in executed_keys_to_remove:
+                del self.executed_tasks[key]
+            
+            # 更新数据库状态为删除，但不触发重新调度
+            return self._update_schedule_without_reschedule(schedule_id, status='deleted')
+            
+        except Exception as e:
+            logger.error(f"删除日程失败: {e}")
+            return {"success": False, "message": f"删除日程失败: {str(e)}"}
+    
+    def _update_schedule_without_reschedule(self, schedule_id: int, **kwargs) -> Dict[str, Any]:
+        """更新日程但不触发重新调度（内部方法）"""
+        try:
+            conn = sqlite3.connect(DB_PATH)
+            cursor = conn.cursor()
+            
+            # 构建更新语句
+            updates = []
+            params = []
+            
+            for field, value in kwargs.items():
+                if value is not None:
+                    if field == 'schedule_time':
+                        # 验证时间格式
+                        try:
+                            datetime.datetime.strptime(value, '%Y-%m-%d %H:%M')
+                        except ValueError:
+                            return {"success": False, "message": "时间格式错误"}
+                    elif field == 'repeat_rule':
+                        if not all(c in '01' for c in value) or len(value) != 7:
+                            return {"success": False, "message": "重复规则格式错误"}
+                    
+                    updates.append(f"{field} = ?")
+                    params.append(value)
+            
+            if not updates:
+                return {"success": False, "message": "没有提供要更新的字段"}
+            
+            updates.append("updated_at = ?")
+            params.append(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
+            params.append(schedule_id)
+            
+            cursor.execute(f"UPDATE schedules SET {', '.join(updates)} WHERE id = ?", params)
+            
+            if cursor.rowcount == 0:
+                conn.close()
+                return {"success": False, "message": "日程不存在"}
+            
+            conn.commit()
+            conn.close()
+            
+            logger.info(f"更新日程成功(无重新调度): ID {schedule_id}")
+            return {"success": True, "message": "日程更新成功"}
+            
+        except Exception as e:
+            logger.error(f"更新日程失败: {e}")
+            return {"success": False, "message": f"更新日程失败: {str(e)}"}
+    
+    def _reschedule_task(self, schedule_id: int):
+        """重新调度任务定时器"""
+        try:
+            logger.info(f"开始重新调度任务 ID {schedule_id}")
+            
+            # 1. 彻底清理task_threads中的记录（包括Timer对象和状态标记）
+            if schedule_id in self.task_threads:
+                task_item = self.task_threads[schedule_id]
+                if isinstance(task_item, threading.Timer):
+                    task_item.cancel()
+                    logger.info(f"已取消任务 ID {schedule_id} 的旧定时器")
+                elif isinstance(task_item, str):
+                    logger.info(f"清理任务 ID {schedule_id} 的状态标记: {task_item}")
+                del self.task_threads[schedule_id]
+            
+            # 2. 彻底清除executed_tasks中的所有相关执行记录
+            # 包括所有可能的时间戳组合
+            executed_keys_to_remove = []
+            for key in list(self.executed_tasks.keys()):
+                # 匹配所有与此schedule_id相关的记录
+                if key.startswith(f"{schedule_id}_") or f"_{schedule_id}_" in key:
+                    executed_keys_to_remove.append(key)
+            
+            for key in executed_keys_to_remove:
+                del self.executed_tasks[key]
+                logger.info(f"已清除任务 ID {schedule_id} 的执行记录: {key}")
+            
+            # 3. 获取更新后的日程信息（包括所有状态）
+            conn = sqlite3.connect(DB_PATH)
+            cursor = conn.cursor()
+            cursor.execute("SELECT * FROM schedules WHERE id = ?", (schedule_id,))
+            row = cursor.fetchone()
+            conn.close()
+            
+            if not row:
+                logger.warning(f"找不到任务 ID {schedule_id}")
+                return
+            
+            # 构建日程对象
+            updated_schedule = {
+                "id": row[0],
+                "title": row[1],
+                "content": row[2],
+                "schedule_time": row[3],
+                "repeat_rule": row[4],
+                "status": row[5],
+                "created_at": row[6],
+                "updated_at": row[7],
+                "uid": row[8] if len(row) > 8 else 0
+            }
+            
+            # 4. 只有active状态的任务才重新调度
+            if updated_schedule['status'] != 'active':
+                logger.info(f"任务 ID {schedule_id} 状态为 {updated_schedule['status']}，不进行调度")
+                return
+            
+            # 5. 计算下次执行时间并重新调度
+            next_time = self.parse_repeat_rule(updated_schedule['repeat_rule'], updated_schedule['schedule_time'])
+            if next_time:
+                current_time = datetime.datetime.now()
+                
+                # 对于刚修改的任务，即使时间刚过期也允许立即执行
+                if next_time > current_time:
+                    self.schedule_task(updated_schedule, next_time)
+                    logger.info(f"任务 ID {schedule_id} 已重新调度到 {next_time}")
+                elif (current_time - next_time).total_seconds() < 300:  # 5分钟内
+                    logger.info(f"任务 ID {schedule_id} 刚过期，立即执行")
+                    self.execute_schedule_task(updated_schedule)
+                    
+                    # 如果是重复任务，计算下一次执行时间
+                    if updated_schedule['repeat_rule'] != '0000000':
+                        # 计算明天或下个周期的执行时间
+                        tomorrow = current_time + datetime.timedelta(days=1)
+                        next_next_time = self.parse_repeat_rule(updated_schedule['repeat_rule'], 
+                                                               tomorrow.strftime('%Y-%m-%d') + ' ' + 
+                                                               updated_schedule['schedule_time'].split(' ')[1])
+                        if next_next_time and next_next_time > current_time:
+                            self.schedule_task(updated_schedule, next_next_time)
+                            logger.info(f"重复任务 ID {schedule_id} 下次执行时间: {next_next_time}")
+                else:
+                    logger.warning(f"任务 ID {schedule_id} 已过期超过5分钟: {next_time}")
+            else:
+                logger.info(f"任务 ID {schedule_id} 不需要调度")
+                
+        except Exception as e:
+            logger.error(f"重新调度任务 ID {schedule_id} 失败: {e}")
+            import traceback
+            logger.error(traceback.format_exc())
+    
+    def get_repeat_text(self, repeat_rule: str) -> str:
+        """获取重复规则文本 - 与web界面保持一致"""
+        if repeat_rule == '0000000':
+            return '单次执行'
+        
+        days = ['周一', '周二', '周三', '周四', '周五', '周六', '周日']
+        repeat_days = []
+        for i in range(7):
+            if repeat_rule[i] == '1':
+                repeat_days.append(days[i])
+        
+        if len(repeat_days) == 7:
+            return '每日重复'
+        elif len(repeat_days) == 5 and repeat_rule[5:7] == '00':  # 工作日
+            return '工作日重复'
+        else:
+            return '重复: ' + ', '.join(repeat_days)
+    
+    def format_datetime(self, date_time_str: str) -> str:
+        """格式化日期时间 - 与web界面保持一致"""
+        try:
+            dt = datetime.datetime.strptime(date_time_str, '%Y-%m-%d %H:%M')
+            return dt.strftime('%Y-%m-%d %H:%M')
+        except ValueError:
+            return date_time_str
+    
+    def parse_natural_language_schedule(self, text: str, uid: int = 0):
+        """解析自然语言日程指令"""
+        try:
+            # 清理输入文本
+            text = text.strip()
+            
+            # 提取时间信息的正则模式
+            time_patterns = [
+                (r'明天\s*(上午|下午|中午|晚上|早上)\s*(\d{1,2})\s*[点时]?(\d{0,2})\s*分?', 1, 'time_with_period'),
+                (r'明天\s*(\d{1,2})\s*[点时](\d{0,2})\s*分?', 1, 'time_only'),
+                (r'后天\s*(上午|下午|中午|晚上|早上)\s*(\d{1,2})\s*[点时]?(\d{0,2})\s*分?', 2, 'time_with_period'),
+                (r'后天\s*(\d{1,2})\s*[点时](\d{0,2})\s*分?', 2, 'time_only'),
+                (r'今天\s*(上午|下午|中午|晚上|早上)\s*(\d{1,2})\s*[点时]?(\d{0,2})\s*分?', 0, 'time_with_period'),
+                (r'今天\s*(\d{1,2})\s*[点时](\d{0,2})\s*分?', 0, 'time_only'),
+                (r'(\d{1,2})\s*分钟后', 0, 'minutes_later'),
+                (r'(\d{1,2})\s*小时后', 0, 'hours_later'),
+            ]
+            
+            # 提取任务内容的模式 - 移除时间和提醒词汇
+            task_extract_patterns = [
+                r'(提醒我|叫我|提醒)\s*(.+)',
+                r'(.+)\s*(提醒|提示)',
+                r'(.+)'  # 最后的兜底模式
+            ]
+            
+            schedule_time = None
+            task_content = None
+            
+            # 尝试匹配时间模式
+            for pattern, day_offset, pattern_type in time_patterns:
+                match = re.search(pattern, text)
+                if match:
+                    try:
+                        base_date = datetime.date.today() + datetime.timedelta(days=day_offset)
+                        
+                        if pattern_type == 'time_with_period':
+                            period = match.group(1)
+                            hour = int(match.group(2))
+                            minute = int(match.group(3)) if match.group(3) else 0
+                            
+                            # 根据时间段调整小时
+                            if period in ['下午', '晚上'] and hour < 12:
+                                hour += 12
+                            elif period in ['上午', '早上'] and hour == 12:
+                                hour = 0
+                            elif period == '中午' and hour != 12:
+                                hour = 12
+                                
+                        elif pattern_type == 'time_only':
+                            hour = int(match.group(1))
+                            minute = int(match.group(2)) if match.group(2) else 0
+                            
+                        elif pattern_type == 'minutes_later':
+                            minutes = int(match.group(1))
+                            target_time = datetime.datetime.now() + datetime.timedelta(minutes=minutes)
+                            schedule_time = target_time.strftime('%Y-%m-%d %H:%M')
+                            break
+                            
+                        elif pattern_type == 'hours_later':
+                            hours = int(match.group(1))
+                            target_time = datetime.datetime.now() + datetime.timedelta(hours=hours)
+                            schedule_time = target_time.strftime('%Y-%m-%d %H:%M')
+                            break
+                        
+                        if pattern_type not in ['minutes_later', 'hours_later']:
+                            # 确保时间合法
+                            if 0 <= hour <= 23 and 0 <= minute <= 59:
+                                schedule_time = f"{base_date.strftime('%Y-%m-%d')} {hour:02d}:{minute:02d}"
+                        
+                        if schedule_time:
+                            # 从原文中移除时间部分
+                            remaining_text = re.sub(pattern, '', text).strip()
+                            break
+                            
+                    except ValueError:
+                        continue
+            
+            # 如果没有找到具体时间，使用默认时间
+            if not schedule_time:
+                # 默认为明天上午9点
+                tomorrow = datetime.date.today() + datetime.timedelta(days=1)
+                schedule_time = f"{tomorrow.strftime('%Y-%m-%d')} 09:00"
+                remaining_text = text
+            else:
+                remaining_text = remaining_text or text
+            
+            # 提取任务内容
+            for pattern in task_extract_patterns:
+                match = re.search(pattern, remaining_text, re.IGNORECASE)
+                if match:
+                    groups = match.groups()
+                    if len(groups) == 2:
+                        # 如果有两个捕获组，选择更有意义的那个
+                        task_content = groups[1] if groups[1] and len(groups[1].strip()) > len(groups[0].strip()) else groups[0]
+                    else:
+                        task_content = groups[0]
+                    task_content = task_content.strip()
+                    
+                    # 清理任务内容中的无用词汇
+                    cleanup_words = ['提醒我', '叫我', '提醒', '提示', '的', '了', '吧', '呀', '啊']
+                    for word in cleanup_words:
+                        task_content = task_content.replace(word, '').strip()
+                    
+                    if task_content:
+                        break
+            
+            # 如果还是没有提取到内容，使用原始文本
+            if not task_content or len(task_content.strip()) < 2:
+                task_content = text
+            
+            # 生成更合适的标题和内容
+            title = task_content
+            content = f"提醒事项：{task_content}"
+            
+            # 调用原有的添加日程功能
+            result = self.add_schedule(title, content, schedule_time, '0000000', uid)
+            
+            # 返回解析结果
+            if result.get('success'):
+                parsed_info = {
+                    "原始指令": text,
+                    "解析的时间": schedule_time,
+                    "提取的任务": task_content,
+                    "生成的标题": title,
+                    "生成的内容": content
+                }
+                result["解析信息"] = parsed_info
+                logger.info(f"自然语言解析成功: {parsed_info}")
+            
+            return result
+            
+        except Exception as e:
+            logger.error(f"自然语言解析失败: {e}")
+            return {"success": False, "message": f"解析指令失败: {str(e)}"}
+    
+    def send_to_fay(self, message: str, uid: int = 0):
+        """发送消息给Fay - 使用v1/chat/completions接口"""
+        print("***********************************************************************")
+        logger.info(f"[DEBUG] send_to_fay 被调用，消息: {message}, uid: {uid}")
+        
+        # 防止消息重复发送
+        msg_hash = hash(f"{message}_{uid}_{datetime.datetime.now().strftime('%Y-%m-%d %H:%M')}")
+        if hasattr(self, '_sent_messages'):
+            if msg_hash in self._sent_messages:
+                logger.warning(f"[DEBUG] 消息在1分钟内已发送过，跳过: {message}")
+                return
+        else:
+            self._sent_messages = set()
+        
+        self._sent_messages.add(msg_hash)
+        
+        try:
+            # 使用线程发送，避免阻塞
+            def send_message():
+                try:
+                    logger.info(f"[DEBUG] 开始发送HTTP请求到Fay API")
+                    # 获取用户名
+                    username = f"User{uid}" if uid > 0 else "User"
+                    
+                    # 构建请求数据 - 使用v1/chat/completions格式
+                    payload = {
+                        "messages": [
+                            {
+                                "role": "user",
+                                "content": message
+                            }
+                        ],
+                        "model": "fay-streaming",
+                        "stream": False  # 使用非流式响应
+                    }
+                    
+                    logger.info(f"[DEBUG] 请求payload: {payload}")
+                    
+                    # 发送HTTP请求到v1/chat/completions接口
+                    response = requests.post(
+                        FAY_API_URL,
+                        json=payload,
+                        headers={
+                            "Content-Type": "application/json"
+                        },
+                        timeout=30
+                    )
+                    
+                    logger.info(f"[DEBUG] HTTP响应状态码: {response.status_code}")
+                    
+                    if response.status_code == 200:
+                        logger.info(f"消息已发送给Fay: {message}")
+                        try:
+                            resp_data = response.json()
+                            logger.debug(f"Fay响应: {resp_data}")
+                        except:
+                            logger.debug(f"Fay响应: {response.text[:200]}")
+                    else:
+                        logger.error(f"Fay API响应错误: {response.status_code} - {response.text}")
+                        
+                except requests.exceptions.RequestException as e:
+                    logger.error(f"发送消息给Fay失败 (网络错误): {e}")
+                except Exception as e:
+                    logger.error(f"发送消息给Fay失败: {e}")
+            
+            thread = threading.Thread(target=send_message)
+            thread.daemon = True
+            thread.start()
+            
+        except Exception as e:
+            logger.error(f"发送消息给Fay失败: {e}")
+    
+    def parse_repeat_rule(self, rule: str, task_time: str) -> Optional[datetime.datetime]:
+        """解析重复规则，返回下次执行时间"""
+        try:
+            task_datetime = datetime.datetime.strptime(task_time, '%Y-%m-%d %H:%M')
+            now = datetime.datetime.now()
+            
+            if rule == '0000000':  # 不重复
+                if task_datetime > now:
+                    return task_datetime
+                else:
+                    return None
+            else:
+                # 重复任务，找到下一个执行时间
+                today = now.date()
+                task_time_obj = task_datetime.time()
+                
+                # 检查今天是否需要执行
+                weekday = today.weekday()  # 0=周一，6=周日
+                if rule[weekday] == '1':
+                    today_task_time = datetime.datetime.combine(today, task_time_obj)
+                    if today_task_time > now:
+                        return today_task_time
+                
+                # 找到下一个执行日期
+                for i in range(1, 8):
+                    next_day = today + datetime.timedelta(days=i)
+                    next_weekday = next_day.weekday()
+                    if rule[next_weekday] == '1':
+                        return datetime.datetime.combine(next_day, task_time_obj)
+                
+                return None
+                
+        except Exception as e:
+            logger.error(f"解析重复规则失败: {e}")
+            return None
+    
+    def execute_schedule_task(self, schedule: Dict[str, Any]):
+        """执行日程任务"""
+        schedule_id = schedule['id']
+        
+        # 检查是否在短时间内已执行过（防止重复执行）
+        now = datetime.datetime.now()
+        executed_key = f"{schedule_id}_{schedule['schedule_time']}"
+        
+        if executed_key in self.executed_tasks:
+            last_executed = self.executed_tasks[executed_key]
+            if (now - last_executed).total_seconds() < 120:  # 2分钟内不重复执行
+                logger.warning(f"[DEBUG] 任务 {schedule['title']} (ID: {schedule_id}) 在2分钟内已执行过，跳过")
+                return
+        
+        logger.info(f"[DEBUG] 开始执行日程任务: {schedule['title']} (ID: {schedule_id}), 时间: {now}")
+        logger.info(f"[DEBUG] task_threads 当前内容: {list(self.task_threads.keys())}")
+        logger.info(f"[DEBUG] executed_tasks 当前内容: {list(self.executed_tasks.keys())}")
+        
+        # 记录执行时间
+        self.executed_tasks[executed_key] = now
+        
+        # 构建消息
+        message = f"【日程提醒】{schedule['title']}: {schedule['content']}"
+        
+        # 发送给Fay
+        logger.info(f"[DEBUG] 准备发送消息给Fay: {message}")
+        self.send_to_fay(message, schedule['uid'])
+        
+        # 标记任务已执行
+        self.task_threads[schedule_id] = "executed"
+        
+        # 如果是非重复任务，直接删除
+        if schedule['repeat_rule'] == '0000000':
+            logger.info(f"[DEBUG] 单次任务执行完成，直接删除: ID {schedule_id}")
+            result = self.delete_schedule(schedule['id'])
+            logger.info(f"[DEBUG] 删除结果: {result}")
+            if not result.get('success'):
+                logger.error(f"[ERROR] 删除任务失败: {result.get('message')}")
+        else:
+            logger.info(f"[DEBUG] 重复任务，保持active状态: ID {schedule_id}")
+        # 注意：重复任务的下次调度会在下一次schedule_loop中自动处理
+    
+    def schedule_task(self, schedule: Dict[str, Any], execute_time: datetime.datetime):
+        """调度任务执行"""
+        schedule_id = schedule['id']
+        
+        # 取消之前的任务（如果是Timer对象）
+        if schedule_id in self.task_threads:
+            if isinstance(self.task_threads[schedule_id], threading.Timer):
+                self.task_threads[schedule_id].cancel()
+            del self.task_threads[schedule_id]
+        
+        # 计算延迟时间
+        current_time = datetime.datetime.now()
+        delay = (execute_time - current_time).total_seconds()
+        
+        if delay > 0:
+            # 创建定时器
+            timer = threading.Timer(delay, self.execute_schedule_task, args=[schedule])
+            timer.start()
+            self.task_threads[schedule_id] = timer
+            logger.info(f"任务已调度: {schedule['title']} 将在 {execute_time} 执行")
+        elif delay > -60:  # 刚过期不到1分钟，立即执行
+            logger.warning(f"[DEBUG] 任务 {schedule['title']} 刚过期 {-delay:.1f} 秒，立即执行")
+            # 直接执行任务
+            self.execute_schedule_task(schedule)
+        else:
+            # 任务已过期超过1分钟，直接标记为已完成（对于非重复任务）
+            logger.warning(f"[DEBUG] 任务 {schedule['title']} 已过期 {-delay/60:.1f} 分钟")
+            if schedule['repeat_rule'] == '0000000':
+                logger.info(f"[DEBUG] 非重复任务已过期，标记为completed: ID {schedule_id}")
+                self.update_schedule(schedule_id, status='completed')
+            # 标记为已处理，防止重复调度
+            self.task_threads[schedule_id] = "expired"
+    
+    def start_scheduler(self):
+        """启动调度器"""
+        
+        # 检查是否已有调度器在运行
+        if os.path.exists(self.scheduler_lock_file):
+            # 检查锁文件的时间，如果超过2分钟认为是死锁
+            try:
+                lock_time = os.path.getmtime(self.scheduler_lock_file)
+                if time.time() - lock_time < 120:  # 2分钟内
+                    logger.info("调度器已在其他进程中运行，跳过启动")
+                    return
+                else:
+                    logger.warning("检测到过期的调度器锁，清理并重新启动")
+                    os.remove(self.scheduler_lock_file)
+            except:
+                pass
+        
+        # 创建锁文件
+        try:
+            with open(self.scheduler_lock_file, 'w') as f:
+                f.write(str(os.getpid()))
+            self.scheduler_running = True
+        except:
+            logger.error("无法创建调度器锁文件")
+            return
+        
+        def schedule_loop():
+            loop_count = 0
+            while self.scheduler_running:
+                try:
+                    loop_count += 1
+                    current_time = datetime.datetime.now()
+                    logger.info(f"[DEBUG] === 调度循环 #{loop_count} 开始 === 时间: {current_time}")
+                    
+                    # 检查锁文件PID是否与当前进程匹配
+                    if os.path.exists(self.scheduler_lock_file):
+                        try:
+                            with open(self.scheduler_lock_file, 'r') as f:
+                                lock_pid = int(f.read().strip())
+                            current_pid = os.getpid()
+                            if lock_pid != current_pid:
+                                logger.error(f"[ERROR] 检测到PID冲突！锁文件PID: {lock_pid}, 当前PID: {current_pid}")
+                                logger.error("[ERROR] 有其他调度器进程在运行，退出当前调度器")
+                                self.scheduler_running = False
+                                break
+                        except:
+                            pass
+                        # 更新锁文件时间
+                        os.utime(self.scheduler_lock_file, None)
+                    else:
+                        logger.error("[ERROR] 锁文件丢失，退出调度器")
+                        self.scheduler_running = False
+                        break
+                    
+                    # 检查是否有重新调度触发文件
+                    reschedule_dir = os.path.dirname(self.scheduler_lock_file)
+                    for filename in os.listdir(reschedule_dir):
+                        if filename.startswith('.reschedule_'):
+                            try:
+                                # 提取schedule_id
+                                schedule_id = int(filename.replace('.reschedule_', ''))
+                                trigger_file = os.path.join(reschedule_dir, filename)
+                                
+                                logger.info(f"[DEBUG] 发现重新调度触发文件: {filename}, 日程ID: {schedule_id}")
+                                
+                                # 删除触发文件
+                                os.remove(trigger_file)
+                                
+                                # 强制重新调度该任务
+                                self._reschedule_task(schedule_id)
+                                logger.info(f"[DEBUG] 已处理重新调度请求: ID {schedule_id}")
+                                
+                            except Exception as e:
+                                logger.error(f"处理重新调度触发文件失败: {e}")
+                    
+                    # 每10分钟清理一次过期的执行记录
+                    if loop_count % 20 == 0:  # 20 * 30秒 = 10分钟
+                        now = datetime.datetime.now()
+                        expired_keys = []
+                        for key, exec_time in self.executed_tasks.items():
+                            if (now - exec_time).total_seconds() > 600:  # 10分钟前的记录
+                                expired_keys.append(key)
+                        for key in expired_keys:
+                            del self.executed_tasks[key]
+                        if expired_keys:
+                            logger.info(f"[DEBUG] 清理了 {len(expired_keys)} 个过期执行记录")
+                    
+                    # 获取所有活跃的日程
+                    schedules = self.get_schedules('active')
+                    logger.info(f"[DEBUG] 本次循环获取到 {len(schedules)} 个活跃任务")
+                    
+                    for schedule in schedules:
+                        logger.info(f"[DEBUG] 处理任务: ID={schedule['id']}, 标题='{schedule['title']}', 状态='{schedule['status']}'")
+                        schedule_id = schedule['id']
+                        
+                        # 解析执行时间
+                        next_time = self.parse_repeat_rule(schedule['repeat_rule'], schedule['schedule_time'])
+                        
+                        logger.debug(f"[DEBUG] 处理任务 ID {schedule_id}: {schedule['title']}, next_time={next_time}, 当前时间={datetime.datetime.now()}")
+                        
+                        if next_time:
+                            # 如果任务已经在调度中，跳过
+                            if schedule_id in self.task_threads:
+                                # 任务已被调度过，不管Timer是否还活着都跳过
+                                # 这防止了同一任务被多次调度
+                                logger.debug(f"[DEBUG] 任务 ID {schedule_id} 已在 task_threads 中，跳过")
+                                continue
+                            
+                            # 只有当任务时间还未到且未被调度时才创建新的Timer
+                            current_time = datetime.datetime.now()
+                            if next_time > current_time:
+                                logger.info(f"调度任务 {schedule['title']} (ID: {schedule_id}) 将在 {next_time} 执行")
+                                self.schedule_task(schedule, next_time)
+                            else:
+                                logger.warning(f"[DEBUG] 任务 ID {schedule_id} 时间已过期: {next_time} < {current_time}")
+                        else:
+                            logger.debug(f"[DEBUG] 任务 ID {schedule_id} parse_repeat_rule 返回 None")
+                    
+                    # 每30秒检查一次（参考agent_service.py的实现）
+                    time.sleep(30)
+                    
+                except Exception as e:
+                    logger.error(f"调度器错误: {e}")
+                    time.sleep(60)
+        
+        # 启动调度线程
+        # 注册退出时清理锁文件
+        def cleanup_lock():
+            if self.scheduler_running and os.path.exists(self.scheduler_lock_file):
+                try:
+                    os.remove(self.scheduler_lock_file)
+                    logger.info("调度器锁文件已清理")
+                except:
+                    pass
+            self.scheduler_running = False
+        
+        atexit.register(cleanup_lock)
+        
+        scheduler_thread = threading.Thread(target=schedule_loop)
+        scheduler_thread.daemon = True
+        scheduler_thread.start()
+        logger.info("日程调度器已启动")
+    
+    def start_web_server(self):
+        """启动Web服务器"""
+        try:
+            # 如果已经有Web服务器在运行，先停止它
+            if self.web_server_process is not None:
+                self.stop_web_server()
+            
+            # 检查web_server.py文件是否存在
+            web_server_path = os.path.join(os.path.dirname(__file__), 'web_server.py')
+            if not os.path.exists(web_server_path):
+                logger.warning("web_server.py 文件不存在，跳过启动Web服务器")
+                return
+            
+            # 启动Web服务器进程
+            self.web_server_process = subprocess.Popen(
+                [sys.executable, 'web_server.py', '--host', '127.0.0.1', '--port', '5011'],
+                cwd=os.path.dirname(__file__),
+                stdout=subprocess.DEVNULL,  # 不显示输出，避免干扰MCP通信
+                stderr=subprocess.DEVNULL
+            )
+            
+            # 等待一小段时间检查进程是否正常启动
+            time.sleep(2)
+            if self.web_server_process and self.web_server_process.poll() is None:
+                logger.info("Web服务器已启动 - 访问地址: http://127.0.0.1:5011")
+            else:
+                logger.warning("Web服务器启动失败")
+                self.web_server_process = None
+                        
+        except Exception as e:
+            logger.error(f"启动Web服务器失败: {e}")
+            self.web_server_process = None
+    
+    def stop_web_server(self):
+        """停止Web服务器"""
+        if self.web_server_process:
+            try:
+                # 先尝试正常终止
+                self.web_server_process.terminate()
+                try:
+                    self.web_server_process.wait(timeout=3)
+                    logger.info("Web服务器已正常停止")
+                except subprocess.TimeoutExpired:
+                    # 如果3秒内没有停止，强制杀死
+                    self.web_server_process.kill()
+                    self.web_server_process.wait(timeout=2)
+                    logger.info("Web服务器已强制停止")
+                self.web_server_process = None
+            except Exception as e:
+                logger.error(f"停止Web服务器失败: {e}")
+                self.web_server_process = None
+
+# 全局日程管理器实例
+schedule_manager = ScheduleManager()
+
+# 注册清理函数
+def cleanup():
+    """清理函数"""
+    try:
+        logger.info("正在清理资源...")
+        schedule_manager.stop_web_server()
+    except Exception as e:
+        logger.error(f"清理资源时出错: {e}")
+
+atexit.register(cleanup)
+
+# 信号处理
+def signal_handler(signum, frame):
+    """信号处理函数"""
+    logger.info(f"收到信号 {signum}，正在退出...")
+    cleanup()
+    sys.exit(0)
+
+# 注册信号处理器
+try:
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+    # Windows特有信号
+    if hasattr(signal, 'SIGBREAK'):
+        signal.signal(signal.SIGBREAK, signal_handler)
+except Exception as e:
+    logger.warning(f"注册信号处理器失败: {e}")
+
+# 创建MCP服务器
+server = Server("schedule-manager")
+
+@server.list_tools()
+async def handle_list_tools() -> List[Tool]:
+    """返回可用工具列表"""
+    return [
+        Tool(
+            name="add_schedule",
+            description="添加新的日程安排",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "title": {
+                        "type": "string",
+                        "description": "日程标题"
+                    },
+                    "content": {
+                        "type": "string", 
+                        "description": "日程详细内容"
+                    },
+                    "schedule_time": {
+                        "type": "string",
+                        "description": "执行时间，格式: YYYY-MM-DD HH:MM 或 HH:MM（默认今天）"
+                    },
+                    "repeat_rule": {
+                        "type": "string",
+                        "description": "重复规则，7位数字，每位代表周一到周日(1=重复,0=不重复)，默认'0000000'",
+                        "default": "0000000"
+                    },
+                    "uid": {
+                        "type": "integer",
+                        "description": "用户ID，默认0",
+                        "default": 0
+                    }
+                },
+                "required": ["title", "content", "schedule_time"]
+            }
+        ),
+        Tool(
+            name="get_schedules",
+            description="获取日程列表",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "status": {
+                        "type": "string",
+                        "description": "日程状态筛选: active(活跃), completed(已完成), deleted(已删除)",
+                        "default": "active"
+                    },
+                    "uid": {
+                        "type": "integer",
+                        "description": "用户ID筛选，不提供则获取所有用户的日程"
+                    }
+                }
+            }
+        ),
+        Tool(
+            name="update_schedule",
+            description="更新日程信息",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "schedule_id": {
+                        "type": "integer",
+                        "description": "日程ID"
+                    },
+                    "title": {
+                        "type": "string",
+                        "description": "新的标题"
+                    },
+                    "content": {
+                        "type": "string",
+                        "description": "新的内容"
+                    },
+                    "schedule_time": {
+                        "type": "string",
+                        "description": "新的执行时间，格式: YYYY-MM-DD HH:MM"
+                    },
+                    "repeat_rule": {
+                        "type": "string",
+                        "description": "新的重复规则"
+                    },
+                    "status": {
+                        "type": "string",
+                        "description": "新的状态: active, completed, deleted"
+                    }
+                },
+                "required": ["schedule_id"]
+            }
+        ),
+        Tool(
+            name="delete_schedule",
+            description="删除日程（软删除）",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "schedule_id": {
+                        "type": "integer",
+                        "description": "要删除的日程ID"
+                    }
+                },
+                "required": ["schedule_id"]
+            }
+        ),
+        Tool(
+            name="parse_natural_schedule",
+            description="解析自然语言日程指令，如'明天上午提醒我开会'、'10分钟后提醒我休息'等",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "text": {
+                        "type": "string",
+                        "description": "用户的自然语言指令，如'明天上午提醒我开会'"
+                    },
+                    "uid": {
+                        "type": "integer",
+                        "description": "用户ID",
+                        "default": 0
+                    }
+                },
+                "required": ["text"]
+            }
+        ),
+        Tool(
+            name="send_message_to_fay",
+            description="直接发送消息给Fay",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "message": {
+                        "type": "string",
+                        "description": "要发送的消息内容"
+                    },
+                    "uid": {
+                        "type": "integer",
+                        "description": "用户ID",
+                        "default": 0
+                    }
+                },
+                "required": ["message"]
+            }
+        )
+    ]
+
+@server.call_tool()
+async def handle_call_tool(name: str, arguments: Dict[str, Any]) -> List[TextContent]:
+    """处理工具调用"""
+    
+    if name == "add_schedule":
+        result = schedule_manager.add_schedule(
+            title=arguments["title"],
+            content=arguments["content"],
+            schedule_time=arguments["schedule_time"],
+            repeat_rule=arguments.get("repeat_rule", "0000000"),
+            uid=arguments.get("uid", 0)
+        )
+        return [TextContent(type="text", text=json.dumps(result, ensure_ascii=False))]
+    
+    elif name == "get_schedules":
+        schedules = schedule_manager.get_schedules(
+            status=arguments.get("status", "active"),
+            uid=arguments.get("uid")
+        )
+        return [TextContent(type="text", text=json.dumps(schedules, ensure_ascii=False, indent=2))]
+    
+    elif name == "update_schedule":
+        result = schedule_manager.update_schedule(
+            schedule_id=arguments["schedule_id"],
+            title=arguments.get("title"),
+            content=arguments.get("content"),
+            schedule_time=arguments.get("schedule_time"),
+            repeat_rule=arguments.get("repeat_rule"),
+            status=arguments.get("status")
+        )
+        return [TextContent(type="text", text=json.dumps(result, ensure_ascii=False))]
+    
+    elif name == "delete_schedule":
+        result = schedule_manager.delete_schedule(arguments["schedule_id"])
+        return [TextContent(type="text", text=json.dumps(result, ensure_ascii=False))]
+    
+    elif name == "parse_natural_schedule":
+        result = schedule_manager.parse_natural_language_schedule(
+            text=arguments["text"],
+            uid=arguments.get("uid", 0)
+        )
+        return [TextContent(type="text", text=json.dumps(result, ensure_ascii=False, indent=2))]
+    
+    elif name == "send_message_to_fay":
+        schedule_manager.send_to_fay(
+            message=arguments["message"],
+            uid=arguments.get("uid", 0)
+        )
+        return [TextContent(type="text", text=json.dumps({"success": True, "message": "消息已发送给Fay"}, ensure_ascii=False))]
+    
+    else:
+        return [TextContent(type="text", text=f"未知工具: {name}")]
+
+async def main():
+    """主函数"""
+    logger.info("Fay日程管理MCP Server 启动中...")
+    
+    try:
+        # 使用stdio传输运行服务器
+        async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
+            # MCP连接建立时启动Web服务器
+            schedule_manager.start_web_server()
+            logger.info("MCP连接已建立，Web服务器已启动")
+            
+            # 使用服务器的标准初始化选项
+            init_opts = server.create_initialization_options()
+            await server.run(read_stream, write_stream, init_opts)
+    except KeyboardInterrupt:
+        logger.info("收到中断信号，正在关闭服务器...")
+    except Exception as e:
+        logger.error(f"MCP服务器运行错误: {e}")
+    finally:
+        # MCP连接断开时关闭Web服务器
+        schedule_manager.stop_web_server()
+        logger.info("MCP服务器已关闭，Web服务器已停止")
+
+if __name__ == "__main__":
+    asyncio.run(main())
\ No newline at end of file
diff --git a/mcp_servers/schedule_manager/web_server.py b/mcp_servers/schedule_manager/web_server.py
new file mode 100644
index 0000000..6bde702
--- /dev/null
+++ b/mcp_servers/schedule_manager/web_server.py
@@ -0,0 +1,386 @@
+#!/usr/bin/env python3
+"""
+Fay日程管理Web服务器
+提供独立的网页界面和API接口
+"""
+
+import os
+import sys
+import json
+import sqlite3
+import datetime
+
+# 检查并安装依赖
+try:
+    from flask import Flask, jsonify, request, send_from_directory
+    from flask_cors import CORS
+except ImportError:
+    print("正在安装必要的依赖包...")
+    import subprocess
+    try:
+        subprocess.check_call([sys.executable, '-m', 'pip', 'install', 'flask', 'flask-cors'])
+        from flask import Flask, jsonify, request, send_from_directory
+        from flask_cors import CORS
+        print("依赖包安装完成")
+    except Exception as e:
+        print(f"安装依赖包失败: {e}")
+        print("请手动运行: pip install flask flask-cors")
+        sys.exit(1)
+
+# 添加项目根目录到Python路径
+project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
+sys.path.insert(0, project_root)
+
+app = Flask(__name__)
+CORS(app)  # 允许跨域请求
+
+# 数据库文件路径
+DB_PATH = os.path.join(os.path.dirname(__file__), 'schedules.db')
+
+class ScheduleWebAPI:
+    """日程管理Web API类"""
+    
+    def __init__(self):
+        self.init_database()
+    
+    def init_database(self):
+        """初始化数据库"""
+        conn = sqlite3.connect(DB_PATH)
+        cursor = conn.cursor()
+        cursor.execute('''
+            CREATE TABLE IF NOT EXISTS schedules (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                title TEXT NOT NULL,
+                content TEXT NOT NULL,
+                schedule_time TEXT NOT NULL,
+                repeat_rule TEXT NOT NULL DEFAULT '0000000',
+                status TEXT NOT NULL DEFAULT 'active',
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL,
+                uid INTEGER DEFAULT 0
+            )
+        ''')
+        conn.commit()
+        conn.close()
+    
+    def get_schedules(self, status='active', uid=None):
+        """获取日程列表"""
+        try:
+            conn = sqlite3.connect(DB_PATH)
+            cursor = conn.cursor()
+            
+            if uid is not None:
+                if status == 'all':
+                    # 'all' 表示显示所有未删除的日程（active + completed）
+                    cursor.execute("SELECT * FROM schedules WHERE status != 'deleted' AND uid = ? ORDER BY schedule_time", (uid,))
+                else:
+                    cursor.execute("SELECT * FROM schedules WHERE status = ? AND uid = ? ORDER BY schedule_time", (status, uid))
+            else:
+                if status == 'all':
+                    # 'all' 表示显示所有未删除的日程（active + completed）
+                    cursor.execute("SELECT * FROM schedules WHERE status != 'deleted' ORDER BY schedule_time")
+                else:
+                    cursor.execute("SELECT * FROM schedules WHERE status = ? ORDER BY schedule_time", (status,))
+            
+            rows = cursor.fetchall()
+            conn.close()
+            
+            schedules = []
+            for row in rows:
+                schedules.append({
+                    "id": row[0],
+                    "title": row[1],
+                    "content": row[2],
+                    "schedule_time": row[3],
+                    "repeat_rule": row[4],
+                    "status": row[5],
+                    "created_at": row[6],
+                    "updated_at": row[7],
+                    "uid": row[8]
+                })
+            
+            return {"success": True, "schedules": schedules}
+            
+        except Exception as e:
+            return {"success": False, "message": f"获取日程列表失败: {str(e)}"}
+    
+    def add_schedule(self, title, content, schedule_time, repeat_rule='0000000', uid=0):
+        """添加日程"""
+        try:
+            # 验证时间格式
+            try:
+                datetime.datetime.strptime(schedule_time, '%Y-%m-%d %H:%M')
+            except ValueError:
+                return {"success": False, "message": "时间格式错误，请使用 YYYY-MM-DD HH:MM 格式"}
+            
+            # 验证重复规则
+            if not all(c in '01' for c in repeat_rule) or len(repeat_rule) != 7:
+                return {"success": False, "message": "重复规则格式错误"}
+            
+            now = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+            
+            conn = sqlite3.connect(DB_PATH)
+            cursor = conn.cursor()
+            cursor.execute(
+                "INSERT INTO schedules (title, content, schedule_time, repeat_rule, created_at, updated_at, uid) VALUES (?, ?, ?, ?, ?, ?, ?)",
+                (title, content, schedule_time, repeat_rule, now, now, uid)
+            )
+            schedule_id = cursor.lastrowid
+            conn.commit()
+            conn.close()
+            
+            return {"success": True, "message": "日程添加成功", "schedule_id": schedule_id}
+            
+        except Exception as e:
+            return {"success": False, "message": f"添加日程失败: {str(e)}"}
+    
+    def update_schedule(self, schedule_id, title=None, content=None, schedule_time=None, repeat_rule=None, status=None):
+        """更新日程"""
+        try:
+            conn = sqlite3.connect(DB_PATH)
+            cursor = conn.cursor()
+            
+            # 先获取当前日程信息
+            cursor.execute("SELECT status, repeat_rule FROM schedules WHERE id = ?", (schedule_id,))
+            current_schedule = cursor.fetchone()
+            if not current_schedule:
+                conn.close()
+                return {"success": False, "message": "日程不存在"}
+            
+            current_status, current_repeat_rule = current_schedule
+            
+            # 构建更新语句
+            updates = []
+            params = []
+            auto_activate = False  # 是否需要自动激活
+            
+            if title is not None:
+                updates.append("title = ?")
+                params.append(title)
+            if content is not None:
+                updates.append("content = ?")
+                params.append(content)
+            if schedule_time is not None:
+                # 验证时间格式
+                try:
+                    new_time = datetime.datetime.strptime(schedule_time, '%Y-%m-%d %H:%M')
+                    updates.append("schedule_time = ?")
+                    params.append(schedule_time)
+                    
+                    # 如果更新了时间，并且当前状态是completed，检查是否需要重新激活
+                    if current_status == 'completed':
+                        now = datetime.datetime.now()
+                        # 如果新时间在未来，或者是重复任务，自动激活
+                        if new_time > now or (repeat_rule or current_repeat_rule) != '0000000':
+                            auto_activate = True
+                            print(f"[Web] 日程 ID {schedule_id} 时间更新，自动从completed恢复为active")
+                            
+                except ValueError:
+                    return {"success": False, "message": "时间格式错误"}
+            if repeat_rule is not None:
+                if not all(c in '01' for c in repeat_rule) or len(repeat_rule) != 7:
+                    return {"success": False, "message": "重复规则格式错误"}
+                updates.append("repeat_rule = ?")
+                params.append(repeat_rule)
+                
+                # 如果从单次改为重复，并且当前是completed，自动激活
+                if current_status == 'completed' and repeat_rule != '0000000':
+                    auto_activate = True
+                    print(f"[Web] 日程 ID {schedule_id} 改为重复任务，自动从completed恢复为active")
+                    
+            # 处理状态更新
+            if status is not None:
+                updates.append("status = ?")
+                params.append(status)
+            elif auto_activate:
+                # 如果需要自动激活，并且没有明确指定状态，则设置为active
+                updates.append("status = ?")
+                params.append('active')
+                print(f"[Web] 日程 ID {schedule_id} 状态设置为active")
+            
+            if not updates:
+                return {"success": False, "message": "没有提供要更新的字段"}
+            
+            updates.append("updated_at = ?")
+            params.append(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
+            params.append(schedule_id)
+            
+            cursor.execute(f"UPDATE schedules SET {', '.join(updates)} WHERE id = ?", params)
+            
+            if cursor.rowcount == 0:
+                conn.close()
+                return {"success": False, "message": "日程不存在"}
+            
+            conn.commit()
+            
+            # 如果有更新时间或状态，通知调度器重新调度（通过创建触发文件）
+            if schedule_time is not None or repeat_rule is not None or status is not None or auto_activate:
+                # 创建一个触发文件，让调度器知道需要重新检查
+                trigger_file = os.path.join(os.path.dirname(__file__), f'.reschedule_{schedule_id}')
+                try:
+                    with open(trigger_file, 'w') as f:
+                        f.write(str(datetime.datetime.now()))
+                    print(f"[Web] 创建重新调度触发文件: {trigger_file}")
+                except:
+                    pass
+            
+            conn.close()
+            
+            if auto_activate:
+                return {"success": True, "message": "日程更新成功，状态已自动恢复为活跃"}
+            else:
+                return {"success": True, "message": "日程更新成功"}
+            
+        except Exception as e:
+            return {"success": False, "message": f"更新日程失败: {str(e)}"}
+    
+    def delete_schedule(self, schedule_id):
+        """删除日程（软删除）"""
+        return self.update_schedule(schedule_id, status='deleted')
+
+# 创建API实例
+schedule_api = ScheduleWebAPI()
+
+# Web路由
+@app.route('/')
+def index():
+    """主页，返回日程管理网页"""
+    return send_from_directory(os.path.dirname(__file__), 'schedule_web.html')
+
+@app.route('/api/schedule/list')
+def api_get_schedules():
+    """获取日程列表API"""
+    status = request.args.get('status', 'all')
+    uid = request.args.get('uid', type=int)
+    result = schedule_api.get_schedules(status, uid)
+    return jsonify(result)
+
+@app.route('/api/schedule/create', methods=['POST'])
+def api_create_schedule():
+    """创建日程API"""
+    data = request.get_json()
+    if not data:
+        return jsonify({"success": False, "message": "无效的请求数据"})
+    
+    title = data.get('title')
+    content = data.get('content', '')
+    schedule_time = data.get('schedule_time')
+    repeat_rule = data.get('repeat_rule', '0000000')
+    uid = data.get('uid', 0)
+    
+    if not title or not schedule_time:
+        return jsonify({"success": False, "message": "标题和时间为必填项"})
+    
+    result = schedule_api.add_schedule(title, content, schedule_time, repeat_rule, uid)
+    return jsonify(result)
+
+@app.route('/api/schedule/update/<int:schedule_id>', methods=['PUT'])
+def api_update_schedule(schedule_id):
+    """更新日程API"""
+    data = request.get_json()
+    if not data:
+        return jsonify({"success": False, "message": "无效的请求数据"})
+    
+    result = schedule_api.update_schedule(
+        schedule_id,
+        title=data.get('title'),
+        content=data.get('content'),
+        schedule_time=data.get('schedule_time'),
+        repeat_rule=data.get('repeat_rule'),
+        status=data.get('status')
+    )
+    return jsonify(result)
+
+@app.route('/api/schedule/complete/<int:schedule_id>', methods=['PUT'])
+def api_complete_schedule(schedule_id):
+    """完成日程API - 直接删除"""
+    result = schedule_api.delete_schedule(schedule_id)
+    return jsonify(result)
+
+@app.route('/api/schedule/delete/<int:schedule_id>', methods=['DELETE'])
+def api_delete_schedule(schedule_id):
+    """删除日程API"""
+    result = schedule_api.delete_schedule(schedule_id)
+    return jsonify(result)
+
+@app.route('/api/health')
+def api_health():
+    """健康检查API"""
+    return jsonify({"status": "ok", "message": "Fay日程管理服务运行正常"})
+
+if __name__ == '__main__':
+    import argparse
+    import signal
+    import atexit
+    import threading
+    import time
+    
+    try:
+        import psutil
+        HAS_PSUTIL = True
+    except ImportError:
+        HAS_PSUTIL = False
+        print("警告: psutil未安装，无法监控父进程")
+    
+    # 获取父进程ID
+    parent_pid = os.getppid()
+    
+    def cleanup():
+        print("Web服务器正在关闭...")
+    
+    def signal_handler(sig, frame):
+        print(f"收到信号 {sig}，正在关闭Web服务器...")
+        cleanup()
+        sys.exit(0)
+    
+    def monitor_parent():
+        """监控父进程，如果父进程不存在则退出"""
+        if not HAS_PSUTIL:
+            return
+            
+        while True:
+            try:
+                # 检查父进程是否还存在
+                if not psutil.pid_exists(parent_pid):
+                    print(f"父进程 {parent_pid} 已退出，关闭Web服务器...")
+                    cleanup()
+                    os._exit(0)  # 强制退出
+                time.sleep(5)  # 每5秒检查一次
+            except Exception as e:
+                print(f"监控父进程时出错: {e}")
+                time.sleep(5)
+    
+    # 注册清理和信号处理
+    atexit.register(cleanup)
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+    
+    # 启动父进程监控线程
+    if HAS_PSUTIL:
+        try:
+            monitor_thread = threading.Thread(target=monitor_parent, daemon=True)
+            monitor_thread.start()
+            print(f"已启动父进程监控 (父进程PID: {parent_pid})")
+        except Exception as e:
+            print(f"启动父进程监控失败: {e}")
+    else:
+        print("跳过父进程监控（psutil不可用）")
+    
+    parser = argparse.ArgumentParser(description='Fay日程管理Web服务器')
+    parser.add_argument('--host', default='127.0.0.1', help='服务器地址')
+    parser.add_argument('--port', default=5011, type=int, help='服务器端口')
+    parser.add_argument('--debug', action='store_true', help='调试模式')
+    
+    args = parser.parse_args()
+    
+    print(f"启动Fay日程管理Web服务器...")
+    print(f"访问地址: http://{args.host}:{args.port}")
+    print(f"API文档: http://{args.host}:{args.port}/api/health")
+    
+    try:
+        app.run(host=args.host, port=args.port, debug=args.debug, use_reloader=False)
+    except KeyboardInterrupt:
+        print("Web服务器已停止")
+    except Exception as e:
+        print(f"Web服务器启动失败: {e}")
+        sys.exit(1)
\ No newline at end of file
diff --git a/scheduler/thread_manager.py b/scheduler/thread_manager.py
index 96107b7..a67c568 100644
--- a/scheduler/thread_manager.py
+++ b/scheduler/thread_manager.py
@@ -38,6 +38,29 @@ def remove_thread(thread: MyThread):
 
 
 def stopAll():
-    for thread in __thread_list:
-        thread.raise_exception()
-        thread.join()
+    """停止所有MyThread线程"""
+    if not __thread_list:
+        return
+    
+    # 先尝试正常停止
+    stopped_threads = []
+    for thread in __thread_list[:]:  # 使用副本避免修改时出错
+        try:
+            if thread.is_alive():
+                thread.raise_exception()
+                stopped_threads.append(thread)
+        except Exception as e:
+            print(f"停止线程异常: {e}")
+    
+    # 等待线程结束，但设置超时避免无限等待
+    import time
+    for thread in stopped_threads:
+        try:
+            thread.join(timeout=2.0)  # 最多等待2秒
+            if thread.is_alive():
+                print(f"线程 {thread.name} 超时未结束")
+        except Exception as e:
+            print(f"等待线程结束异常: {e}")
+    
+    # 清空线程列表
+    __thread_list.clear()
diff --git a/test/mcp_stdio_example.py b/test/mcp_stdio_example.py
new file mode 100644
index 0000000..74eefc7
--- /dev/null
+++ b/test/mcp_stdio_example.py
@@ -0,0 +1,156 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+本文件是一个最小可用的 MCP STDIO（本地）服务器示例。
+
+运行:
+  python test/mcp_stdio_example.py
+
+在 UI 中添加本地 MCP 服务器时:
+  transport: stdio
+  command: python
+  args: ["test/mcp_stdio_example.py"]
+  cwd: 项目根目录 (可选)
+
+提供的工具:
+  - ping() -> "pong"
+  - echo(text: str)
+  - upper(text: str)
+  - add(a: int, b: int)
+  - now(fmt: str = "%Y-%m-%d %H:%M:%S") -> 当前时间格式化
+
+注意: 返回内容遵循 MCP 协议，使用 TextContent 包装文本。
+"""
+
+import asyncio
+import os
+import sys
+from datetime import datetime
+
+try:
+    # 核心 MCP 服务器 API（低层）
+    from mcp.server import Server
+    from mcp.server.stdio import stdio_server
+    from mcp import types
+except Exception as e:
+    print("[mcp_stdio_example] 请先安装 mcp 包: pip install mcp", file=sys.stderr)
+    raise
+
+
+server = Server("Fay STDIO Example")
+
+# --- 定义工具清单（低层 API 需要手动注册 list_tools 和 call_tool）---
+TOOLS: list[types.Tool] = [
+    types.Tool(
+        name="ping",
+        description="连通性检查：若提供 host 则执行系统 ping，否则返回 pong",
+        inputSchema={
+            "type": "object",
+            "properties": {"host": {"type": "string"}},
+            "required": []
+        }
+    ),
+    types.Tool(
+        name="echo",
+        description="返回相同文本",
+        inputSchema={
+            "type": "object",
+            "properties": {"text": {"type": "string"}},
+            "required": ["text"]
+        }
+    ),
+    types.Tool(
+        name="upper",
+        description="将文本转为大写",
+        inputSchema={
+            "type": "object",
+            "properties": {"text": {"type": "string"}},
+            "required": ["text"]
+        }
+    ),
+    types.Tool(
+        name="add",
+        description="两个整数求和",
+        inputSchema={
+            "type": "object",
+            "properties": {"a": {"type": "integer"}, "b": {"type": "integer"}},
+            "required": ["a", "b"]
+        }
+    ),
+    types.Tool(
+        name="now",
+        description="返回当前时间，默认格式为 %Y-%m-%d %H:%M:%S，可通过 fmt 指定",
+        inputSchema={
+            "type": "object",
+            "properties": {"fmt": {"type": "string"}},
+            "required": []
+        }
+    ),
+]
+
+
+@server.list_tools()
+async def list_tools() -> list[types.Tool]:
+    return TOOLS
+
+
+@server.call_tool()
+async def call_tool(name: str, arguments: dict) -> list[types.TextContent]:
+    try:
+        match name:
+            case "ping":
+                host = (arguments or {}).get("host")
+                if host:
+                    # 在不同平台调用系统 ping，避免 Windows 下 shlex.quote 与 shell=True 的兼容问题
+                    import platform, subprocess
+                    is_win = platform.system().lower().startswith("win")
+                    cmd = ["ping", ("-n" if is_win else "-c"), "2", str(host)]
+                    try:
+                        out = subprocess.run(cmd, shell=False, capture_output=True, text=True, timeout=8)
+                        ok = (out.returncode == 0)
+                        stdout = out.stdout or ""
+                        # 截取最后几行摘要
+                        lines = [line for line in stdout.strip().splitlines() if line.strip()]
+                        summary = lines[-6:] if lines else []
+                        text = ("SUCCESS\n" if ok else "FAIL\n") + "\n".join(summary)
+                    except Exception as e:
+                        text = f"执行 ping 出错: {type(e).__name__}: {e}"
+                    return [types.TextContent(type="text", text=text)]
+                else:
+                    return [types.TextContent(type="text", text="pong")]
+            case "echo":
+                return [types.TextContent(type="text", text=str(arguments.get("text", "")))]
+            case "upper":
+                return [types.TextContent(type="text", text=str(arguments.get("text", "")).upper())]
+            case "add":
+                a = int(arguments.get("a", 0))
+                b = int(arguments.get("b", 0))
+                return [types.TextContent(type="text", text=str(a + b))]
+            case "now":
+                fmt = arguments.get("fmt") or "%Y-%m-%d %H:%M:%S"
+                try:
+                    txt = datetime.now().strftime(fmt)
+                except Exception:
+                    txt = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                return [types.TextContent(type="text", text=txt)]
+            case _:
+                return [types.TextContent(type="text", text=f"未知工具: {name}")]
+    except Exception as e:
+        # 返回错误信息（isError将由框架根据异常处理）
+        return [types.TextContent(type="text", text=f"调用异常: {e}")]
+
+
+async def main() -> None:
+    # 通过 STDIO 暴露 MCP Server
+    async with stdio_server() as (read_stream, write_stream):
+        # 显式开启 tools 能力，避免部分版本下未注册导致 list_tools/call_tool 问题
+        init_opts = server.create_initialization_options()
+        await server.run(read_stream, write_stream, init_opts)
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        pass
+
diff --git a/test/test_fay_gpt_stream.py b/test/test_fay_gpt_stream.py
index fec2c6a..050c389 100644
--- a/test/test_fay_gpt_stream.py
+++ b/test/test_fay_gpt_stream.py
@@ -10,7 +10,7 @@ def test_gpt(prompt):
     data = {
         'model': 'fay-streaming',
         'messages': [
-            {'role': 'user_device_32_6', 'content': prompt}
+            {'role': 'User', 'content': prompt}
         ],
         'stream': True  # 启用流式传输
     }