diff --git a/tools/memory_visualizer/CHANGELOG.md b/tools/memory_visualizer/CHANGELOG.md
new file mode 100644
index 000000000..d21bd5a7a
--- /dev/null
+++ b/tools/memory_visualizer/CHANGELOG.md
@@ -0,0 +1,108 @@
+# 🔄 更新日志 - 记忆图可视化工具
+
+## v1.1 - 2025-11-06
+
+### ✨ 新增功能
+
+1. **📂 文件选择器**
+   - 自动搜索所有可用的记忆图数据文件
+   - 支持在Web界面中切换不同的数据文件
+   - 显示文件大小、修改时间等信息
+   - 高亮显示当前使用的文件
+
+2. **🔍 智能文件搜索**
+   - 自动查找 `data/memory_graph/graph_store.json`
+   - 搜索所有备份文件 `graph_store_*.json`
+   - 搜索 `data/backup/` 目录下的历史数据
+   - 按修改时间排序,自动使用最新文件
+
+3. **📊 增强的文件信息显示**
+   - 在侧边栏显示当前文件信息
+   - 包含文件名、大小、修改时间
+   - 实时更新,方便追踪
+
+### 🔧 改进
+
+- 更友好的错误提示
+- 无数据文件时显示引导信息
+- 优化用户体验
+
+### 🎯 使用方法
+
+```bash
+# 启动可视化工具
+python run_visualizer_simple.py
+
+# 或直接运行
+python tools/memory_visualizer/visualizer_simple.py
+```
+
+在Web界面中:
+1. 点击侧边栏的 "选择文件" 按钮
+2. 浏览所有可用的数据文件
+3. 点击任意文件切换数据源
+4. 图形会自动重新加载
+
+### 📸 新界面预览
+
+侧边栏新增:
+```
+┌─────────────────────────┐
+│ 📂 数据文件              │
+│ ┌──────────┬──────────┐ │
+│ │ 选择文件 │ 刷新列表 │ │
+│ └──────────┴──────────┘ │
+│ ┌─────────────────────┐ │
+│ │ 📄 graph_store.json │ │
+│ │ 大小: 125 KB        │ │
+│ │ 修改: 2025-11-06    │ │
+│ └─────────────────────┘ │
+└─────────────────────────┘
+```
+
+文件选择对话框:
+```
+┌────────────────────────────────┐
+│ 📂 选择数据文件         [×]    │
+├────────────────────────────────┤
+│ ┌────────────────────────────┐ │
+│ │ 📄 graph_store.json [当前] │ │
+│ │ 125 KB | 2025-11-06 09:30  │ │
+│ └────────────────────────────┘ │
+│ ┌────────────────────────────┐ │
+│ │ 📄 graph_store_backup.json │ │
+│ │ 120 KB | 2025-11-05 18:00  │ │
+│ └────────────────────────────┘ │
+└────────────────────────────────┘
+```
+
+---
+
+## v1.0 - 2025-11-06 (初始版本)
+
+### 🎉 首次发布
+
+- ✅ 基于Vis.js的交互式图形可视化
+- ✅ 节点类型颜色分类
+- ✅ 搜索和过滤功能
+- ✅ 统计信息显示
+- ✅ 节点详情查看
+- ✅ 数据导出功能
+- ✅ 独立版服务器(快速启动)
+- ✅ 完整版服务器(实时数据)
+
+---
+
+## 🔮 计划中的功能 (v1.2+)
+
+- [ ] 时间轴视图 - 查看记忆随时间的变化
+- [ ] 3D可视化模式
+- [ ] 记忆重要性热力图
+- [ ] 关系强度可视化
+- [ ] 导出为图片/PDF
+- [ ] 记忆路径追踪
+- [ ] 多文件对比视图
+- [ ] 性能优化 - 支持更大规模图形
+- [ ] 移动端适配
+
+欢迎提出建议和需求! 🚀
diff --git a/tools/memory_visualizer/FILE_ORGANIZATION.md b/tools/memory_visualizer/FILE_ORGANIZATION.md
new file mode 100644
index 000000000..a3dd2d1aa
--- /dev/null
+++ b/tools/memory_visualizer/FILE_ORGANIZATION.md
@@ -0,0 +1,163 @@
+# 📁 可视化工具文件整理完成
+
+## ✅ 整理结果
+
+### 新的目录结构
+
+```
+tools/memory_visualizer/
+├── visualizer.ps1              ⭐ 统一启动脚本（主入口）
+├── visualizer_simple.py        # 独立版服务器
+├── visualizer_server.py        # 完整版服务器
+├── generate_sample_data.py     # 测试数据生成器
+├── test_visualizer.py          # 测试脚本
+├── run_visualizer.py           # Python 运行脚本（独立版）
+├── run_visualizer_simple.py    # Python 运行脚本（简化版）
+├── start_visualizer.bat        # Windows 批处理启动脚本
+├── start_visualizer.ps1        # PowerShell 启动脚本
+├── start_visualizer.sh         # Linux/Mac 启动脚本
+├── requirements.txt            # Python 依赖
+├── templates/                  # HTML 模板
+│   └── visualizer.html        # 可视化界面
+├── docs/                       # 文档目录
+│   ├── VISUALIZER_README.md
+│   ├── VISUALIZER_GUIDE.md
+│   └── VISUALIZER_INSTALL_COMPLETE.md
+├── README.md                   # 主说明文档
+├── QUICKSTART.md              # 快速开始指南
+└── CHANGELOG.md               # 更新日志
+```
+
+### 根目录保留文件
+
+```
+项目根目录/
+├── visualizer.ps1              # 快捷启动脚本（指向 tools/memory_visualizer/visualizer.ps1）
+└── tools/memory_visualizer/    # 所有可视化工具文件
+```
+
+## 🚀 使用方法
+
+### 推荐方式：使用统一启动脚本
+
+```powershell
+# 在项目根目录
+.\visualizer.ps1
+
+# 或在工具目录
+cd tools\memory_visualizer
+.\visualizer.ps1
+```
+
+### 命令行参数
+
+```powershell
+# 直接启动独立版（推荐）
+.\visualizer.ps1 -Simple
+
+# 启动完整版
+.\visualizer.ps1 -Full
+
+# 生成测试数据
+.\visualizer.ps1 -Generate
+
+# 运行测试
+.\visualizer.ps1 -Test
+```
+
+## 📋 整理内容
+
+### 已移动的文件
+
+从项目根目录移动到 `tools/memory_visualizer/`：
+
+1. **脚本文件**
+   - `generate_sample_data.py`
+   - `run_visualizer.py`
+   - `run_visualizer_simple.py`
+   - `test_visualizer.py`
+   - `start_visualizer.bat`
+   - `start_visualizer.ps1`
+   - `start_visualizer.sh`
+   - `visualizer.ps1`
+
+2. **文档文件** → `docs/` 子目录
+   - `VISUALIZER_GUIDE.md`
+   - `VISUALIZER_INSTALL_COMPLETE.md`
+   - `VISUALIZER_README.md`
+
+### 已创建的新文件
+
+1. **统一启动脚本**
+   - `tools/memory_visualizer/visualizer.ps1` - 功能齐全的统一入口
+
+2. **快捷脚本**
+   - `visualizer.ps1`（根目录）- 快捷方式，指向实际脚本
+
+3. **更新的文档**
+   - `tools/memory_visualizer/README.md` - 更新为反映新结构
+
+## 🎯 优势
+
+### 整理前的问题
+- ❌ 文件散落在根目录
+- ❌ 多个启动脚本功能重复
+- ❌ 文档分散不便管理
+- ❌ 不清楚哪个是主入口
+
+### 整理后的改进
+- ✅ 所有文件集中在 `tools/memory_visualizer/`
+- ✅ 单一统一的启动脚本 `visualizer.ps1`
+- ✅ 文档集中在 `docs/` 子目录
+- ✅ 清晰的主入口和快捷方式
+- ✅ 更好的可维护性
+
+## 📝 功能对比
+
+### 旧的方式（整理前）
+```powershell
+# 需要记住多个脚本名称
+.\start_visualizer.ps1
+.\run_visualizer.py
+.\run_visualizer_simple.py
+.\generate_sample_data.py
+```
+
+### 新的方式（整理后）
+```powershell
+# 只需要一个统一的脚本
+.\visualizer.ps1              # 交互式菜单
+.\visualizer.ps1 -Simple      # 启动独立版
+.\visualizer.ps1 -Generate    # 生成数据
+.\visualizer.ps1 -Test        # 运行测试
+```
+
+## 🔧 维护说明
+
+### 添加新功能
+1. 在 `tools/memory_visualizer/` 目录下添加新文件
+2. 如需启动选项，在 `visualizer.ps1` 中添加新参数
+3. 更新 `README.md` 文档
+
+### 更新文档
+1. 主文档：`tools/memory_visualizer/README.md`
+2. 详细文档：`tools/memory_visualizer/docs/`
+
+## ✅ 测试结果
+
+- ✅ 统一启动脚本正常工作
+- ✅ 独立版服务器成功启动（端口 5001）
+- ✅ 数据加载成功（725 节点，769 边）
+- ✅ Web 界面正常访问
+- ✅ 所有文件已整理到位
+
+## 📚 相关文档
+
+- [README](tools/memory_visualizer/README.md) - 主要说明文档
+- [QUICKSTART](tools/memory_visualizer/QUICKSTART.md) - 快速开始指南  
+- [CHANGELOG](tools/memory_visualizer/CHANGELOG.md) - 更新日志
+- [详细指南](tools/memory_visualizer/docs/VISUALIZER_GUIDE.md) - 完整使用指南
+
+---
+
+整理完成时间：2025-11-06
diff --git a/tools/memory_visualizer/QUICKSTART.md b/tools/memory_visualizer/QUICKSTART.md
new file mode 100644
index 000000000..92e521c3c
--- /dev/null
+++ b/tools/memory_visualizer/QUICKSTART.md
@@ -0,0 +1,279 @@
+# 记忆图可视化工具 - 快速入门指南
+
+## 🎯 方案选择
+
+我为你创建了**两个版本**的可视化工具:
+
+### 1️⃣ 独立版 (推荐 ⭐)
+- **文件**: `tools/memory_visualizer/visualizer_simple.py`
+- **优点**: 
+  - 直接读取存储文件,无需初始化完整系统
+  - 启动快速
+  - 占用资源少
+- **适用**: 快速查看已有记忆数据
+
+### 2️⃣ 完整版
+- **文件**: `tools/memory_visualizer/visualizer_server.py`
+- **优点**:
+  - 实时数据
+  - 支持更多功能
+- **缺点**: 
+  - 需要完整初始化记忆管理器
+  - 启动较慢
+
+## 🚀 快速开始
+
+### 步骤 1: 安装依赖
+
+**Windows (PowerShell):**
+```powershell
+# 依赖会自动检查和安装
+.\start_visualizer.ps1
+```
+
+**Windows (CMD):**
+```cmd
+start_visualizer.bat
+```
+
+**Linux/Mac:**
+```bash
+chmod +x start_visualizer.sh
+./start_visualizer.sh
+```
+
+**手动安装依赖:**
+```bash
+# 使用虚拟环境
+.\.venv\Scripts\python.exe -m pip install flask flask-cors
+
+# 或全局安装
+pip install flask flask-cors
+```
+
+### 步骤 2: 确保有数据
+
+如果还没有记忆数据,可以:
+
+**选项A**: 运行Bot生成实际数据
+```bash
+python bot.py
+# 与Bot交互一会儿,让它积累一些记忆
+```
+
+**选项B**: 生成测试数据 (如果测试脚本可用)
+```bash
+python test_visualizer.py
+# 选择选项 1: 生成测试数据
+```
+
+### 步骤 3: 启动可视化服务器
+
+**方式一: 使用启动脚本 (推荐 ⭐)**
+
+Windows PowerShell:
+```powershell
+.\start_visualizer.ps1
+```
+
+Windows CMD:
+```cmd
+start_visualizer.bat
+```
+
+Linux/Mac:
+```bash
+./start_visualizer.sh
+```
+
+**方式二: 手动启动**
+
+使用虚拟环境:
+```bash
+# Windows
+.\.venv\Scripts\python.exe tools/memory_visualizer/visualizer_simple.py
+
+# Linux/Mac
+.venv/bin/python tools/memory_visualizer/visualizer_simple.py
+```
+
+或使用系统Python:
+```bash
+python tools/memory_visualizer/visualizer_simple.py
+```
+
+服务器将在 http://127.0.0.1:5001 启动
+
+### 步骤 4: 打开浏览器
+
+访问对应的地址,开始探索记忆图! 🎉
+
+## 🎨 界面功能
+
+### 左侧栏
+
+1. **🔍 搜索框**
+   - 输入关键词搜索相关记忆
+   - 结果会在图中高亮显示
+
+2. **📊 统计信息**
+   - 节点总数
+   - 边总数
+   - 记忆总数
+   - 图密度
+
+3. **🎨 节点类型图例**
+   - 🔴 主体 (SUBJECT) - 记忆的主语
+   - 🔵 主题 (TOPIC) - 动作或状态
+   - 🟢 客体 (OBJECT) - 宾语
+   - 🟠 属性 (ATTRIBUTE) - 延伸属性
+   - 🟣 值 (VALUE) - 属性的具体值
+
+4. **🔧 过滤器**
+   - 勾选/取消勾选来显示/隐藏特定类型的节点
+   - 实时更新图形
+
+5. **ℹ️ 节点信息**
+   - 点击任意节点查看详细信息
+   - 显示节点类型、内容、创建时间等
+
+### 右侧主区域
+
+1. **控制按钮**
+   - 🔄 刷新图形: 重新加载最新数据
+   - 📐 适应窗口: 自动调整图形大小
+   - 💾 导出数据: 下载JSON格式的图数据
+
+2. **交互式图形**
+   - **拖动节点**: 点击并拖动单个节点
+   - **拖动画布**: 按住空白处拖动整个图形
+   - **缩放**: 使用鼠标滚轮放大/缩小
+   - **点击节点**: 查看详细信息
+   - **物理模拟**: 节点会自动排列,避免重叠
+
+## 🎮 操作技巧
+
+### 查看特定类型的节点
+1. 在左侧过滤器中取消勾选不需要的类型
+2. 图形会自动更新,只显示选中的类型
+
+### 查找特定记忆
+1. 在搜索框输入关键词(如: "小明", "吃饭")
+2. 点击"搜索"按钮
+3. 相关节点会被选中并自动聚焦
+
+### 整理混乱的图形
+1. 点击"适应窗口"按钮
+2. 或者刷新页面重新初始化布局
+
+### 导出数据进行分析
+1. 点击"导出数据"按钮
+2. JSON文件会自动下载
+3. 可以用于进一步的数据分析或备份
+
+## 🎯 示例场景
+
+### 场景1: 了解记忆图整体结构
+1. 启动可视化工具
+2. 观察不同颜色的节点分布
+3. 查看统计信息了解数量
+4. 使用过滤器逐个类型查看
+
+### 场景2: 追踪特定主题的记忆
+1. 在搜索框输入主题关键词(如: "学习")
+2. 点击搜索
+3. 查看高亮的相关节点
+4. 点击节点查看详情
+
+### 场景3: 调试记忆系统
+1. 创建一条新记忆
+2. 刷新可视化页面
+3. 查看新节点和边是否正确创建
+4. 验证节点类型和关系
+
+## 🐛 常见问题
+
+### Q: 页面显示空白或没有数据?
+**A**: 
+1. 检查是否有记忆数据: 查看 `data/memory_graph/` 目录
+2. 确保记忆系统已启用: 检查 `config/bot_config.toml` 中 `[memory] enable = true`
+3. 尝试生成一些测试数据
+
+### Q: 节点太多,看不清楚?
+**A**:
+1. 使用过滤器只显示某些类型
+2. 使用搜索功能定位特定节点
+3. 调整浏览器窗口大小,点击"适应窗口"
+
+### Q: 如何更新数据?
+**A**:
+- **独立版**: 点击"刷新图形"或访问 `/api/reload`
+- **完整版**: 点击"刷新图形"会自动加载最新数据
+
+### Q: 端口被占用怎么办?
+**A**: 修改启动脚本中的端口号:
+```python
+run_server(host='127.0.0.1', port=5002, debug=True)  # 改为其他端口
+```
+
+## 🎨 自定义配置
+
+### 修改节点颜色
+
+编辑 `templates/visualizer.html`,找到:
+
+```javascript
+const nodeColors = {
+    'SUBJECT': '#FF6B6B',    // 改为你喜欢的颜色
+    'TOPIC': '#4ECDC4',
+    // ...
+};
+```
+
+### 修改物理引擎参数
+
+在同一文件中找到 `physics` 配置:
+
+```javascript
+physics: {
+    barnesHut: {
+        gravitationalConstant: -8000,  // 调整引力
+        springLength: 150,             // 调整弹簧长度
+        // ...
+    }
+}
+```
+
+### 修改数据加载限制
+
+编辑对应的服务器文件,修改 `get_all_memories()` 的limit参数。
+
+## 📝 文件结构
+
+```
+tools/memory_visualizer/
+├── README.md                    # 详细文档
+├── requirements.txt             # 依赖列表
+├── visualizer_server.py         # 完整版服务器
+├── visualizer_simple.py         # 独立版服务器 ⭐
+└── templates/
+    └── visualizer.html          # Web界面模板
+
+run_visualizer.py                # 快速启动脚本
+test_visualizer.py              # 测试和演示脚本
+```
+
+## 🚀 下一步
+
+现在你可以:
+
+1. ✅ 启动可视化工具查看现有数据
+2. ✅ 与Bot交互生成更多记忆
+3. ✅ 使用可视化工具验证记忆结构
+4. ✅ 根据需要自定义样式和配置
+
+祝你使用愉快! 🎉
+
+---
+
+如有问题,请查看 `tools/memory_visualizer/README.md` 获取更多帮助。
diff --git a/tools/memory_visualizer/README.md b/tools/memory_visualizer/README.md
new file mode 100644
index 000000000..9e203d28f
--- /dev/null
+++ b/tools/memory_visualizer/README.md
@@ -0,0 +1,201 @@
+# 🦊 记忆图可视化工具
+
+一个交互式的 Web 可视化工具，用于查看和分析 MoFox Bot 的记忆图结构。
+
+## 📁 目录结构
+
+```
+tools/memory_visualizer/
+├── visualizer.ps1              # 统一启动脚本（主入口）⭐
+├── visualizer_simple.py        # 独立版服务器（推荐）
+├── visualizer_server.py        # 完整版服务器
+├── generate_sample_data.py     # 测试数据生成器
+├── test_visualizer.py          # 测试脚本
+├── requirements.txt            # Python 依赖
+├── templates/                  # HTML 模板
+│   └── visualizer.html        # 可视化界面
+├── docs/                       # 文档目录
+│   ├── VISUALIZER_README.md
+│   ├── VISUALIZER_GUIDE.md
+│   └── VISUALIZER_INSTALL_COMPLETE.md
+├── README.md                   # 本文件
+├── QUICKSTART.md              # 快速开始指南
+└── CHANGELOG.md               # 更新日志
+```
+
+## 🚀 快速开始
+
+### 方式 1：交互式菜单（推荐）
+
+```powershell
+# 在项目根目录运行
+.\visualizer.ps1
+
+# 或在工具目录运行
+cd tools\memory_visualizer
+.\visualizer.ps1
+```
+
+### 方式 2：命令行参数
+
+```powershell
+# 启动独立版（推荐，快速）
+.\visualizer.ps1 -Simple
+
+# 启动完整版（需要 MemoryManager）
+.\visualizer.ps1 -Full
+
+# 生成测试数据
+.\visualizer.ps1 -Generate
+
+# 运行测试
+.\visualizer.ps1 -Test
+
+# 查看帮助
+.\visualizer.ps1 -Help
+```
+
+## 📊 两个版本的区别
+
+### 独立版（Simple）- 推荐
+- ✅ **快速启动**：直接读取数据文件，无需初始化 MemoryManager
+- ✅ **轻量级**：只依赖 Flask 和 vis.js
+- ✅ **稳定**：不依赖主系统运行状态
+- 📌 **端口**：5001
+- 📁 **数据源**：`data/memory_graph/*.json`
+
+### 完整版（Full）
+- 🔄 **实时数据**：使用 MemoryManager 获取最新数据
+- 🔌 **集成**：与主系统深度集成
+- ⚡ **功能完整**：支持所有高级功能
+- 📌 **端口**：5000
+- 📁 **数据源**：MemoryManager
+
+## ✨ 主要功能
+
+1. **交互式图形可视化**
+   - 🎨 5 种节点类型（主体、主题、客体、属性、值）
+   - 🔗 完整路径高亮显示
+   - 🔍 点击节点查看连接关系
+   - 📐 自动布局和缩放
+
+2. **高级筛选**
+   - ☑️ 按节点类型筛选
+   - 🔎 关键词搜索
+   - 📊 统计信息实时更新
+
+3. **智能高亮**
+   - 💡 点击节点高亮所有连接路径（递归探索）
+   - 👻 无关节点变为半透明
+   - 🎯 自动聚焦到相关子图
+
+4. **物理引擎优化**
+   - 🚀 智能布局算法
+   - ⏱️ 自动停止防止持续运行
+   - 🔄 筛选后自动重新布局
+
+5. **数据管理**
+   - 📂 多文件选择器
+   - 💾 导出图形数据
+   - 🔄 实时刷新
+
+## 🔧 依赖安装
+
+脚本会自动检查并安装依赖，也可以手动安装：
+
+```powershell
+# 激活虚拟环境
+.\.venv\Scripts\Activate.ps1
+
+# 安装依赖
+pip install -r tools/memory_visualizer/requirements.txt
+```
+
+**所需依赖：**
+- Flask >= 2.3.0
+- flask-cors >= 4.0.0
+
+## 📖 使用说明
+
+### 1. 查看记忆图
+1. 启动服务器（推荐独立版）
+2. 在浏览器打开 http://127.0.0.1:5001
+3. 等待数据加载完成
+
+### 2. 探索连接关系
+1. **点击节点**：查看与该节点相关的所有连接路径
+2. **点击空白处**：恢复所有节点显示
+3. **使用筛选器**：按类型过滤节点
+
+### 3. 搜索记忆
+1. 在搜索框输入关键词
+2. 点击搜索按钮
+3. 相关节点会自动高亮
+
+### 4. 查看统计
+- 左侧面板显示实时统计信息
+- 节点数、边数、记忆数
+- 图密度等指标
+
+## 🎨 节点颜色说明
+
+- 🔴 **主体（SUBJECT）**：红色 (#FF6B6B)
+- 🔵 **主题（TOPIC）**：青色 (#4ECDC4)
+- 🟦 **客体（OBJECT）**：蓝色 (#45B7D1)
+- 🟠 **属性（ATTRIBUTE）**：橙色 (#FFA07A)
+- 🟢 **值（VALUE）**：绿色 (#98D8C8)
+
+## 🐛 常见问题
+
+### 问题 1：没有数据显示
+**解决方案：**
+1. 检查 `data/memory_graph/` 目录是否存在数据文件
+2. 运行 `.\visualizer.ps1 -Generate` 生成测试数据
+3. 确保 Bot 已经运行过并生成了记忆数据
+
+### 问题 2：物理引擎一直运行
+**解决方案：**
+- 新版本已修复此问题
+- 物理引擎会在稳定后自动停止（最多 5 秒）
+
+### 问题 3：筛选后节点排版错乱
+**解决方案：**
+- 新版本已修复此问题
+- 筛选后会自动重新布局
+
+### 问题 4：无法查看完整连接路径
+**解决方案：**
+- 新版本使用 BFS 算法递归探索所有连接
+- 点击节点即可查看完整路径
+
+## 📝 开发说明
+
+### 添加新功能
+1. 编辑 `visualizer_simple.py` 或 `visualizer_server.py`
+2. 修改 `templates/visualizer.html` 更新界面
+3. 更新 `requirements.txt` 添加新依赖
+4. 运行测试：`.\visualizer.ps1 -Test`
+
+### 调试
+```powershell
+# 启动 Flask 调试模式
+$env:FLASK_DEBUG = "1"
+python tools/memory_visualizer/visualizer_simple.py
+```
+
+## 📚 相关文档
+
+- [快速开始指南](QUICKSTART.md)
+- [更新日志](CHANGELOG.md)
+- [详细使用指南](docs/VISUALIZER_GUIDE.md)
+
+## 🆘 获取帮助
+
+遇到问题？
+1. 查看 [常见问题](#常见问题)
+2. 运行 `.\visualizer.ps1 -Help` 查看帮助
+3. 查看项目文档目录
+
+## 📄 许可证
+
+与 MoFox Bot 主项目相同
diff --git a/tools/memory_visualizer/README.md.bak b/tools/memory_visualizer/README.md.bak
new file mode 100644
index 000000000..893550c2b
--- /dev/null
+++ b/tools/memory_visualizer/README.md.bak
@@ -0,0 +1,163 @@
+# 🦊 MoFox Bot 记忆图可视化工具
+
+这是一个交互式的Web界面,用于可视化和探索MoFox Bot的记忆图结构。
+
+## ✨ 功能特性
+
+- **交互式图形可视化**: 使用Vis.js展示节点和边的关系
+- **实时数据**: 直接从记忆管理器读取最新数据
+- **节点类型分类**: 不同颜色区分不同类型的节点
+  - 🔴 主体 (SUBJECT)
+  - 🔵 主题 (TOPIC)
+  - 🟢 客体 (OBJECT)
+  - 🟠 属性 (ATTRIBUTE)
+  - 🟣 值 (VALUE)
+- **搜索功能**: 快速查找相关记忆
+- **过滤器**: 按节点类型过滤显示
+- **统计信息**: 实时显示图的统计数据
+- **节点详情**: 点击节点查看详细信息
+- **自由缩放拖动**: 支持图形的交互式操作
+- **数据导出**: 导出当前图形数据为JSON
+
+## 🚀 快速开始
+
+### 1. 安装依赖
+
+```bash
+pip install flask flask-cors
+```
+
+### 2. 启动服务器
+
+在项目根目录运行:
+
+```bash
+python tools/memory_visualizer/visualizer_server.py
+```
+
+或者使用便捷脚本:
+
+```bash
+python run_visualizer.py
+```
+
+### 3. 打开浏览器
+
+访问: http://127.0.0.1:5000
+
+## 📊 界面说明
+
+### 主界面布局
+
+```
+┌─────────────────────────────────────────────────┐
+│  侧边栏                  │  主内容区              │
+│  - 搜索框               │  - 控制按钮             │
+│  - 统计信息             │  - 图形显示             │
+│  - 节点类型图例          │                        │
+│  - 过滤器               │                        │
+│  - 节点详情             │                        │
+└─────────────────────────────────────────────────┘
+```
+
+### 操作说明
+
+- **🔍 搜索**: 在搜索框输入关键词,点击"搜索"按钮查找相关记忆
+- **🔄 刷新图形**: 重新加载最新的记忆图数据
+- **📐 适应窗口**: 自动调整图形大小以适应窗口
+- **💾 导出数据**: 将当前图形数据导出为JSON文件
+- **✅ 过滤器**: 勾选/取消勾选不同类型的节点来过滤显示
+- **👆 点击节点**: 点击任意节点查看详细信息
+- **🖱️ 拖动**: 按住鼠标拖动节点或整个图形
+- **🔍 缩放**: 使用鼠标滚轮缩放图形
+
+## 🔧 配置说明
+
+### 修改服务器配置
+
+在 `visualizer_server.py` 的最后:
+
+```python
+if __name__ == '__main__':
+    run_server(
+        host='127.0.0.1',  # 监听地址
+        port=5000,         # 端口号
+        debug=True         # 调试模式
+    )
+```
+
+### API端点
+
+- `GET /` - 主页面
+- `GET /api/graph/full` - 获取完整记忆图数据
+- `GET /api/memory/<memory_id>` - 获取特定记忆详情
+- `GET /api/search?q=<query>&limit=<n>` - 搜索记忆
+- `GET /api/stats` - 获取统计信息
+
+## 📝 技术栈
+
+- **后端**: Flask (Python Web框架)
+- **前端**: 
+  - Vis.js (图形可视化库)
+  - 原生JavaScript
+  - CSS3 (渐变、动画、响应式布局)
+- **数据**: 直接从MoFox Bot记忆管理器读取
+
+## 🐛 故障排除
+
+### 问题: 无法启动服务器
+
+**原因**: 记忆系统未启用或配置错误
+
+**解决**: 检查 `config/bot_config.toml` 确保:
+
+```toml
+[memory]
+enable = true
+data_dir = "data/memory_graph"
+```
+
+### 问题: 图形显示空白
+
+**原因**: 没有记忆数据
+
+**解决**: 
+1. 先运行Bot让其生成一些记忆
+2. 或者运行测试脚本生成测试数据
+
+### 问题: 节点太多,图形混乱
+
+**解决**: 
+1. 使用过滤器只显示某些类型的节点
+2. 使用搜索功能定位特定记忆
+3. 调整物理引擎参数(在visualizer.html中)
+
+## 🎨 自定义样式
+
+修改 `templates/visualizer.html` 中的样式定义:
+
+```javascript
+const nodeColors = {
+    'SUBJECT': '#FF6B6B',    // 主体颜色
+    'TOPIC': '#4ECDC4',      // 主题颜色
+    'OBJECT': '#45B7D1',     // 客体颜色
+    'ATTRIBUTE': '#FFA07A',  // 属性颜色
+    'VALUE': '#98D8C8'       // 值颜色
+};
+```
+
+## 📈 性能优化
+
+对于大型图形(>1000节点):
+
+1. **禁用物理引擎**: 在stabilization完成后自动禁用
+2. **限制显示节点**: 使用过滤器或搜索
+3. **分页加载**: 修改API使用分页
+
+## 🤝 贡献
+
+欢迎提交Issue和Pull Request!
+
+## 📄 许可
+
+与MoFox Bot主项目相同的许可证
diff --git a/tools/memory_visualizer/docs/VISUALIZER_INSTALL_COMPLETE.md b/tools/memory_visualizer/docs/VISUALIZER_INSTALL_COMPLETE.md
new file mode 100644
index 000000000..561db41ef
--- /dev/null
+++ b/tools/memory_visualizer/docs/VISUALIZER_INSTALL_COMPLETE.md
@@ -0,0 +1,210 @@
+# ✅ 记忆图可视化工具 - 安装完成
+
+## 🎉 恭喜！可视化工具已成功创建！
+
+---
+
+## 📦 已创建的文件
+
+```
+Bot/
+├── visualizer.ps1 ⭐⭐⭐           # 统一启动脚本 (推荐使用)
+├── start_visualizer.ps1           # 独立版快速启动
+├── start_visualizer.bat           # CMD版启动脚本
+├── generate_sample_data.py        # 示例数据生成器
+├── VISUALIZER_README.md ⭐        # 快速参考指南
+├── VISUALIZER_GUIDE.md            # 完整使用指南
+└── tools/memory_visualizer/
+    ├── visualizer_simple.py ⭐    # 独立版服务器 (推荐)
+    ├── visualizer_server.py       # 完整版服务器
+    ├── README.md                  # 详细文档
+    ├── QUICKSTART.md              # 快速入门
+    ├── CHANGELOG.md               # 更新日志
+    └── templates/
+        └── visualizer.html ⭐     # 精美Web界面
+```
+
+---
+
+## 🚀 立即开始 (3秒)
+
+### 方法 1: 使用统一启动脚本 (最简单 ⭐⭐⭐)
+
+```powershell
+.\visualizer.ps1
+```
+
+然后按提示选择:
+- **1** = 独立版 (推荐，快速)
+- **2** = 完整版 (实时数据)
+- **3** = 生成示例数据
+
+### 方法 2: 直接启动
+
+```powershell
+# 如果还没有数据，先生成
+.\.venv\Scripts\python.exe generate_sample_data.py
+
+# 启动可视化
+.\start_visualizer.ps1
+
+# 打开浏览器
+# http://127.0.0.1:5001
+```
+
+---
+
+## 🎨 功能亮点
+
+### ✨ 核心功能
+- 🎯 **交互式图形**: 拖动、缩放、点击
+- 🎨 **颜色分类**: 5种节点类型自动上色
+- 🔍 **智能搜索**: 快速定位相关记忆
+- 🔧 **灵活过滤**: 按节点类型筛选
+- 📊 **实时统计**: 节点、边、记忆数量
+- 💾 **数据导出**: JSON格式导出
+
+### 📂 独立版特色 (推荐)
+- ⚡ **秒速启动**: 2秒内完成
+- 📁 **文件切换**: 浏览所有历史数据
+- 🔄 **自动搜索**: 智能查找数据文件
+- 💚 **低资源**: 占用资源极少
+
+### 🔥 完整版特色
+- 🔴 **实时数据**: 与Bot同步
+- 🔄 **自动更新**: 无需刷新
+- 🛠️ **完整功能**: 使用全部API
+
+---
+
+## 📊 界面预览
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  侧边栏                    │  主区域                     │
+│  ┌─────────────────────┐  │  ┌───────────────────────┐ │
+│  │ 📂 数据文件          │  │  │ 🔄 📐 💾 控制按钮    │ │
+│  │ [选择] [刷新]       │  │  └───────────────────────┘ │
+│  │ 📄 当前: xxx.json   │  │  ┌───────────────────────┐ │
+│  └─────────────────────┘  │  │                       │ │
+│                           │  │   交互式图形可视化      │ │
+│  ┌─────────────────────┐  │  │                       │ │
+│  │ 🔍 搜索记忆          │  │  │   🔴 主体  🔵 主题    │ │
+│  │ [...........] [搜索] │  │  │   🟢 客体  🟠 属性    │ │
+│  └─────────────────────┘  │  │   🟣 值               │ │
+│                           │  │                       │ │
+│  📊 统计: 12节点 15边    │  │   可拖动、缩放、点击     │ │
+│                           │  │                       │ │
+│  🎨 节点类型图例          │  └───────────────────────┘ │
+│  🔧 过滤器               │                             │
+│  ℹ️  节点信息             │                             │
+└─────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 🎯 快速命令
+
+```powershell
+# 统一启动 (推荐)
+.\visualizer.ps1
+
+# 生成示例数据
+.\.venv\Scripts\python.exe generate_sample_data.py
+
+# 独立版 (端口 5001)
+.\start_visualizer.ps1
+
+# 完整版 (端口 5000)
+.\.venv\Scripts\python.exe tools/memory_visualizer/visualizer_server.py
+```
+
+---
+
+## 📖 文档索引
+
+### 快速参考 (必读 ⭐)
+- **VISUALIZER_README.md** - 快速参考卡片
+- **VISUALIZER_GUIDE.md** - 完整使用指南
+
+### 详细文档
+- **tools/memory_visualizer/README.md** - 技术文档
+- **tools/memory_visualizer/QUICKSTART.md** - 快速入门
+- **tools/memory_visualizer/CHANGELOG.md** - 版本历史
+
+---
+
+## 💡 使用建议
+
+### 🎯 对于首次使用者
+1. 运行 `.\visualizer.ps1`
+2. 选择 `3` 生成示例数据
+3. 选择 `1` 启动独立版
+4. 打开浏览器访问 http://127.0.0.1:5001
+5. 开始探索！
+
+### 🔧 对于开发者
+1. 运行Bot积累真实数据
+2. 启动完整版可视化: `.\visualizer.ps1` → `2`
+3. 实时查看记忆图变化
+4. 调试和优化
+
+### 📊 对于数据分析
+1. 使用独立版查看历史数据
+2. 切换不同时期的数据文件
+3. 使用搜索和过滤功能
+4. 导出数据进行分析
+
+---
+
+## 🐛 常见问题
+
+### Q: 未找到数据文件？
+**A**: 运行 `.\visualizer.ps1` 选择 `3` 生成示例数据
+
+### Q: 端口被占用？
+**A**: 修改对应服务器文件中的端口号，或关闭占用端口的程序
+
+### Q: 两个版本有什么区别？
+**A**: 
+- **独立版**: 快速，读文件，可切换，推荐日常使用
+- **完整版**: 实时，用内存，完整功能，推荐开发调试
+
+### Q: 图形显示混乱？
+**A**: 
+1. 使用过滤器减少节点
+2. 点击"适应窗口"
+3. 刷新页面
+
+---
+
+## 🎉 开始使用
+
+### 立即启动
+```powershell
+.\visualizer.ps1
+```
+
+### 访问地址
+- 独立版: http://127.0.0.1:5001
+- 完整版: http://127.0.0.1:5000
+
+---
+
+## 🤝 反馈与支持
+
+如有问题或建议，请查看:
+- 📖 `VISUALIZER_GUIDE.md` - 完整使用指南
+- 📝 `tools/memory_visualizer/README.md` - 技术文档
+
+---
+
+## 🌟 特别感谢
+
+感谢你使用 MoFox Bot 记忆图可视化工具！
+
+**享受探索记忆图的乐趣！** 🚀🦊
+
+---
+
+_最后更新: 2025-11-06_
diff --git a/tools/memory_visualizer/docs/VISUALIZER_README.md b/tools/memory_visualizer/docs/VISUALIZER_README.md
new file mode 100644
index 000000000..a340b7b44
--- /dev/null
+++ b/tools/memory_visualizer/docs/VISUALIZER_README.md
@@ -0,0 +1,159 @@
+# 🎯 记忆图可视化工具 - 快速参考
+
+## 🚀 快速启动
+
+### 推荐方式 (交互式菜单)
+```powershell
+.\visualizer.ps1
+```
+
+然后选择:
+- **选项 1**: 独立版 (快速，推荐) ⭐
+- **选项 2**: 完整版 (实时数据)
+- **选项 3**: 生成示例数据
+
+---
+
+## 📋 各版本对比
+
+| 特性 | 独立版 ⭐ | 完整版 |
+|------|---------|--------|
+| **启动速度** | 🚀 快速 (2秒) | ⏱️ 较慢 (5-10秒) |
+| **数据源** | 📂 文件 | 💾 内存 (实时) |
+| **文件切换** | ✅ 支持 | ❌ 不支持 |
+| **资源占用** | 💚 低 | 💛 中等 |
+| **端口** | 5001 | 5000 |
+| **适用场景** | 查看历史数据、调试 | 实时监控、开发 |
+
+---
+
+## 🔧 手动启动命令
+
+### 独立版 (推荐)
+```powershell
+# Windows
+.\start_visualizer.ps1
+
+# 或直接运行
+.\.venv\Scripts\python.exe tools/memory_visualizer/visualizer_simple.py
+```
+访问: http://127.0.0.1:5001
+
+### 完整版
+```powershell
+.\.venv\Scripts\python.exe tools/memory_visualizer/visualizer_server.py
+```
+访问: http://127.0.0.1:5000
+
+### 生成示例数据
+```powershell
+.\.venv\Scripts\python.exe generate_sample_data.py
+```
+
+---
+
+## 📊 功能一览
+
+### 🎨 可视化功能
+- ✅ 交互式图形 (拖动、缩放、点击)
+- ✅ 节点类型颜色分类
+- ✅ 实时搜索和过滤
+- ✅ 统计信息展示
+- ✅ 节点详情查看
+
+### 📂 数据管理
+- ✅ 自动搜索数据文件
+- ✅ 多文件切换 (独立版)
+- ✅ 数据导出 (JSON格式)
+- ✅ 文件信息显示
+
+---
+
+## 🎯 使用场景
+
+### 1️⃣ 首次使用
+```powershell
+# 1. 生成示例数据
+.\visualizer.ps1
+# 选择: 3
+
+# 2. 启动可视化
+.\visualizer.ps1
+# 选择: 1
+
+# 3. 打开浏览器
+# 访问: http://127.0.0.1:5001
+```
+
+### 2️⃣ 查看实际数据
+```powershell
+# 先运行Bot生成记忆
+# 然后启动可视化
+.\visualizer.ps1
+# 选择: 1 (独立版) 或 2 (完整版)
+```
+
+### 3️⃣ 调试记忆系统
+```powershell
+# 使用完整版，实时查看变化
+.\visualizer.ps1
+# 选择: 2
+```
+
+---
+
+## 🐛 故障排除
+
+### ❌ 问题: 未找到数据文件
+**解决**: 
+```powershell
+.\visualizer.ps1
+# 选择 3 生成示例数据
+```
+
+### ❌ 问题: 端口被占用
+**解决**: 
+- 独立版: 修改 `visualizer_simple.py` 中的 `port=5001`
+- 完整版: 修改 `visualizer_server.py` 中的 `port=5000`
+
+### ❌ 问题: 数据加载失败
+**可能原因**: 
+- 数据文件格式不正确
+- 文件损坏
+
+**解决**: 
+1. 检查 `data/memory_graph/` 目录
+2. 重新生成示例数据
+3. 查看终端错误信息
+
+---
+
+## 📚 相关文档
+
+- **完整指南**: `VISUALIZER_GUIDE.md`
+- **快速入门**: `tools/memory_visualizer/QUICKSTART.md`
+- **详细文档**: `tools/memory_visualizer/README.md`
+- **更新日志**: `tools/memory_visualizer/CHANGELOG.md`
+
+---
+
+## 💡 提示
+
+1. **首次使用**: 先生成示例数据 (选项 3)
+2. **查看历史**: 使用独立版，可以切换不同数据文件
+3. **实时监控**: 使用完整版，与Bot同时运行
+4. **性能优化**: 大型图使用过滤器和搜索
+5. **快捷键**: 
+   - `Ctrl + 滚轮`: 缩放
+   - 拖动空白: 移动画布
+   - 点击节点: 查看详情
+
+---
+
+## 🎉 开始探索！
+
+```powershell
+.\visualizer.ps1
+```
+
+享受你的记忆图之旅！🚀🦊
diff --git a/tools/memory_visualizer/requirements.txt b/tools/memory_visualizer/requirements.txt
new file mode 100644
index 000000000..d21b4d428
--- /dev/null
+++ b/tools/memory_visualizer/requirements.txt
@@ -0,0 +1,9 @@
+# 记忆图可视化工具依赖
+
+# Web框架
+flask>=2.3.0
+flask-cors>=4.0.0
+
+# 其他依赖由主项目提供
+# - src.memory_graph
+# - src.config
diff --git a/tools/memory_visualizer/run_visualizer.py b/tools/memory_visualizer/run_visualizer.py
new file mode 100644
index 000000000..bc3b027a0
--- /dev/null
+++ b/tools/memory_visualizer/run_visualizer.py
@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+"""
+记忆图可视化工具启动脚本
+
+快速启动记忆图可视化Web服务器
+"""
+
+import sys
+from pathlib import Path
+
+# 添加项目根目录到路径
+project_root = Path(__file__).parent
+sys.path.insert(0, str(project_root))
+
+from tools.memory_visualizer.visualizer_server import run_server
+
+if __name__ == '__main__':
+    print("=" * 60)
+    print("🦊 MoFox Bot - 记忆图可视化工具")
+    print("=" * 60)
+    print()
+    print("📊 启动可视化服务器...")
+    print("🌐 访问地址: http://127.0.0.1:5000")
+    print("⏹️  按 Ctrl+C 停止服务器")
+    print()
+    print("=" * 60)
+    
+    try:
+        run_server(
+            host='127.0.0.1',
+            port=5000,
+            debug=True
+        )
+    except KeyboardInterrupt:
+        print("\n\n👋 服务器已停止")
+    except Exception as e:
+        print(f"\n❌ 启动失败: {e}")
+        sys.exit(1)
diff --git a/tools/memory_visualizer/run_visualizer_simple.py b/tools/memory_visualizer/run_visualizer_simple.py
new file mode 100644
index 000000000..15aaad493
--- /dev/null
+++ b/tools/memory_visualizer/run_visualizer_simple.py
@@ -0,0 +1,39 @@
+"""
+快速启动脚本 - 记忆图可视化工具 (独立版)
+
+使用说明:
+1. 直接运行此脚本启动可视化服务器
+2. 工具会自动搜索可用的数据文件
+3. 如果找到多个文件,会使用最新的文件
+4. 你也可以在Web界面中选择其他文件
+"""
+
+import sys
+from pathlib import Path
+
+# 添加项目根目录
+project_root = Path(__file__).parent
+sys.path.insert(0, str(project_root))
+
+if __name__ == '__main__':
+    print("=" * 70)
+    print("🦊 MoFox Bot - 记忆图可视化工具 (独立版)")
+    print("=" * 70)
+    print()
+    print("✨ 特性:")
+    print("  • 自动搜索可用的数据文件")
+    print("  • 支持在Web界面中切换文件")
+    print("  • 快速启动,无需完整初始化")
+    print()
+    print("=" * 70)
+    
+    try:
+        from tools.memory_visualizer.visualizer_simple import run_server
+        run_server(host='127.0.0.1', port=5001, debug=True)
+    except KeyboardInterrupt:
+        print("\n\n👋 服务器已停止")
+    except Exception as e:
+        print(f"\n❌ 启动失败: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
diff --git a/tools/memory_visualizer/start_visualizer.bat b/tools/memory_visualizer/start_visualizer.bat
new file mode 100644
index 000000000..dbc916108
--- /dev/null
+++ b/tools/memory_visualizer/start_visualizer.bat
@@ -0,0 +1,53 @@
+@echo off
+REM 记忆图可视化工具启动脚本 - CMD版本
+
+echo ======================================================================
+echo 🦊 MoFox Bot - 记忆图可视化工具
+echo ======================================================================
+echo.
+
+REM 检查虚拟环境
+set VENV_PYTHON=.venv\Scripts\python.exe
+if not exist "%VENV_PYTHON%" (
+    echo ❌ 未找到虚拟环境: %VENV_PYTHON%
+    echo.
+    echo 请先创建虚拟环境:
+    echo   python -m venv .venv
+    echo   .venv\Scripts\activate.bat
+    echo   pip install -r requirements.txt
+    echo.
+    exit /b 1
+)
+
+echo ✅ 使用虚拟环境: %VENV_PYTHON%
+echo.
+
+REM 检查依赖
+echo 🔍 检查依赖...
+"%VENV_PYTHON%" -c "import flask; import flask_cors" 2>nul
+if errorlevel 1 (
+    echo ⚠️  缺少依赖，正在安装...
+    "%VENV_PYTHON%" -m pip install flask flask-cors --quiet
+    if errorlevel 1 (
+        echo ❌ 安装依赖失败
+        exit /b 1
+    )
+    echo ✅ 依赖安装完成
+)
+
+echo ✅ 依赖检查完成
+echo.
+
+REM 显示信息
+echo 📊 启动可视化服务器...
+echo 🌐 访问地址: http://127.0.0.1:5001
+echo ⏹️  按 Ctrl+C 停止服务器
+echo.
+echo ======================================================================
+echo.
+
+REM 启动服务器
+"%VENV_PYTHON%" "tools\memory_visualizer\visualizer_simple.py"
+
+echo.
+echo 👋 服务器已停止
diff --git a/tools/memory_visualizer/start_visualizer.ps1 b/tools/memory_visualizer/start_visualizer.ps1
new file mode 100644
index 000000000..ebfa10fff
--- /dev/null
+++ b/tools/memory_visualizer/start_visualizer.ps1
@@ -0,0 +1,65 @@
+#!/usr/bin/env pwsh
+# 记忆图可视化工具启动脚本 - PowerShell版本
+
+Write-Host "=" -NoNewline -ForegroundColor Cyan
+Write-Host ("=" * 69) -ForegroundColor Cyan
+Write-Host "🦊 MoFox Bot - 记忆图可视化工具" -ForegroundColor Yellow
+Write-Host "=" -NoNewline -ForegroundColor Cyan
+Write-Host ("=" * 69) -ForegroundColor Cyan
+Write-Host ""
+
+# 检查虚拟环境
+$venvPath = ".venv\Scripts\python.exe"
+if (-not (Test-Path $venvPath)) {
+    Write-Host "❌ 未找到虚拟环境: $venvPath" -ForegroundColor Red
+    Write-Host ""
+    Write-Host "请先创建虚拟环境:" -ForegroundColor Yellow
+    Write-Host "  python -m venv .venv" -ForegroundColor Cyan
+    Write-Host "  .\.venv\Scripts\Activate.ps1" -ForegroundColor Cyan
+    Write-Host "  pip install -r requirements.txt" -ForegroundColor Cyan
+    Write-Host ""
+    exit 1
+}
+
+Write-Host "✅ 使用虚拟环境: $venvPath" -ForegroundColor Green
+Write-Host ""
+
+# 检查依赖
+Write-Host "🔍 检查依赖..." -ForegroundColor Cyan
+& $venvPath -c "import flask; import flask_cors" 2>$null
+if ($LASTEXITCODE -ne 0) {
+    Write-Host "⚠️  缺少依赖，正在安装..." -ForegroundColor Yellow
+    & $venvPath -m pip install flask flask-cors --quiet
+    if ($LASTEXITCODE -ne 0) {
+        Write-Host "❌ 安装依赖失败" -ForegroundColor Red
+        exit 1
+    }
+    Write-Host "✅ 依赖安装完成" -ForegroundColor Green
+}
+
+Write-Host "✅ 依赖检查完成" -ForegroundColor Green
+Write-Host ""
+
+# 显示信息
+Write-Host "📊 启动可视化服务器..." -ForegroundColor Cyan
+Write-Host "🌐 访问地址: " -NoNewline -ForegroundColor White
+Write-Host "http://127.0.0.1:5001" -ForegroundColor Blue
+Write-Host "⏹️  按 Ctrl+C 停止服务器" -ForegroundColor Yellow
+Write-Host ""
+Write-Host "=" -NoNewline -ForegroundColor Cyan
+Write-Host ("=" * 69) -ForegroundColor Cyan
+Write-Host ""
+
+# 启动服务器
+try {
+    & $venvPath "tools\memory_visualizer\visualizer_simple.py"
+}
+catch {
+    Write-Host ""
+    Write-Host "❌ 启动失败: $_" -ForegroundColor Red
+    exit 1
+}
+finally {
+    Write-Host ""
+    Write-Host "👋 服务器已停止" -ForegroundColor Yellow
+}
diff --git a/tools/memory_visualizer/start_visualizer.sh b/tools/memory_visualizer/start_visualizer.sh
new file mode 100644
index 000000000..d07820303
--- /dev/null
+++ b/tools/memory_visualizer/start_visualizer.sh
@@ -0,0 +1,53 @@
+#!/bin/bash
+# 记忆图可视化工具启动脚本 - Bash版本 (Linux/Mac)
+
+echo "======================================================================"
+echo "🦊 MoFox Bot - 记忆图可视化工具"
+echo "======================================================================"
+echo ""
+
+# 检查虚拟环境
+VENV_PYTHON=".venv/bin/python"
+if [ ! -f "$VENV_PYTHON" ]; then
+    echo "❌ 未找到虚拟环境: $VENV_PYTHON"
+    echo ""
+    echo "请先创建虚拟环境:"
+    echo "  python -m venv .venv"
+    echo "  source .venv/bin/activate"
+    echo "  pip install -r requirements.txt"
+    echo ""
+    exit 1
+fi
+
+echo "✅ 使用虚拟环境: $VENV_PYTHON"
+echo ""
+
+# 检查依赖
+echo "🔍 检查依赖..."
+$VENV_PYTHON -c "import flask; import flask_cors" 2>/dev/null
+if [ $? -ne 0 ]; then
+    echo "⚠️  缺少依赖，正在安装..."
+    $VENV_PYTHON -m pip install flask flask-cors --quiet
+    if [ $? -ne 0 ]; then
+        echo "❌ 安装依赖失败"
+        exit 1
+    fi
+    echo "✅ 依赖安装完成"
+fi
+
+echo "✅ 依赖检查完成"
+echo ""
+
+# 显示信息
+echo "📊 启动可视化服务器..."
+echo "🌐 访问地址: http://127.0.0.1:5001"
+echo "⏹️  按 Ctrl+C 停止服务器"
+echo ""
+echo "======================================================================"
+echo ""
+
+# 启动服务器
+$VENV_PYTHON "tools/memory_visualizer/visualizer_simple.py"
+
+echo ""
+echo "👋 服务器已停止"
diff --git a/tools/memory_visualizer/templates/visualizer.html b/tools/memory_visualizer/templates/visualizer.html
new file mode 100644
index 000000000..dd40d97ae
--- /dev/null
+++ b/tools/memory_visualizer/templates/visualizer.html
@@ -0,0 +1,1175 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>MoFox Bot - 记忆图可视化</title>
+    <script type="text/javascript" src="https://unpkg.com/vis-network/standalone/umd/vis-network.min.js"></script>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            height: 100vh;
+            overflow: hidden;
+        }
+
+        .container {
+            display: flex;
+            height: 100vh;
+            gap: 10px;
+            padding: 10px;
+        }
+
+        .sidebar {
+            width: 320px;
+            background: rgba(255, 255, 255, 0.95);
+            border-radius: 12px;
+            box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
+            backdrop-filter: blur(10px);
+            padding: 20px;
+            overflow-y: auto;
+            display: flex;
+            flex-direction: column;
+            gap: 15px;
+        }
+
+        .main-content {
+            flex: 1;
+            display: flex;
+            flex-direction: column;
+            gap: 10px;
+        }
+
+        .graph-container {
+            flex: 1;
+            background: rgba(255, 255, 255, 0.95);
+            border-radius: 12px;
+            box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
+            backdrop-filter: blur(10px);
+            overflow: hidden;
+            position: relative;
+        }
+
+        #memory-graph {
+            width: 100%;
+            height: 100%;
+        }
+
+        .controls {
+            background: rgba(255, 255, 255, 0.95);
+            border-radius: 12px;
+            box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
+            backdrop-filter: blur(10px);
+            padding: 15px 20px;
+        }
+
+        h1 {
+            color: #333;
+            font-size: 24px;
+            margin-bottom: 10px;
+            border-bottom: 3px solid #667eea;
+            padding-bottom: 10px;
+        }
+
+        h2 {
+            color: #555;
+            font-size: 16px;
+            margin-bottom: 10px;
+            font-weight: 600;
+        }
+
+        .search-box {
+            display: flex;
+            gap: 10px;
+            margin-bottom: 15px;
+        }
+
+        .search-box input {
+            flex: 1;
+            padding: 10px;
+            border: 2px solid #e0e0e0;
+            border-radius: 8px;
+            font-size: 14px;
+            transition: border-color 0.3s;
+        }
+
+        .search-box input:focus {
+            outline: none;
+            border-color: #667eea;
+        }
+
+        .btn {
+            padding: 10px 20px;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            border: none;
+            border-radius: 8px;
+            cursor: pointer;
+            font-size: 14px;
+            font-weight: 500;
+            transition: transform 0.2s, box-shadow 0.2s;
+        }
+
+        .btn:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 4px 12px rgba(102, 126, 234, 0.4);
+        }
+
+        .btn:active {
+            transform: translateY(0);
+        }
+
+        .btn-secondary {
+            background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+        }
+
+        .stats {
+            display: grid;
+            grid-template-columns: repeat(2, 1fr);
+            gap: 10px;
+        }
+
+        .stat-item {
+            background: linear-gradient(135deg, #667eea15 0%, #764ba215 100%);
+            padding: 12px;
+            border-radius: 8px;
+            text-align: center;
+        }
+
+        .stat-value {
+            font-size: 24px;
+            font-weight: bold;
+            color: #667eea;
+        }
+
+        .stat-label {
+            font-size: 12px;
+            color: #666;
+            margin-top: 4px;
+        }
+
+        .legend {
+            display: flex;
+            flex-direction: column;
+            gap: 8px;
+        }
+
+        .legend-item {
+            display: flex;
+            align-items: center;
+            gap: 10px;
+            padding: 8px;
+            background: #f8f9fa;
+            border-radius: 6px;
+            font-size: 13px;
+        }
+
+        .legend-color {
+            width: 24px;
+            height: 24px;
+            border-radius: 50%;
+            border: 2px solid #fff;
+            box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+        }
+
+        .filter-group {
+            display: flex;
+            flex-direction: column;
+            gap: 8px;
+        }
+
+        .filter-item {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            padding: 6px;
+            background: #f8f9fa;
+            border-radius: 6px;
+        }
+
+        .filter-item input[type="checkbox"] {
+            width: 18px;
+            height: 18px;
+            cursor: pointer;
+        }
+
+        .filter-item label {
+            flex: 1;
+            font-size: 13px;
+            cursor: pointer;
+        }
+
+        .loading {
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            text-align: center;
+            color: #667eea;
+            font-size: 18px;
+            font-weight: 500;
+        }
+
+        .loading-spinner {
+            width: 50px;
+            height: 50px;
+            border: 4px solid #f3f3f3;
+            border-top: 4px solid #667eea;
+            border-radius: 50%;
+            animation: spin 1s linear infinite;
+            margin: 0 auto 15px;
+        }
+
+        @keyframes spin {
+            0% { transform: rotate(0deg); }
+            100% { transform: rotate(360deg); }
+        }
+
+        .info-panel {
+            background: #f8f9fa;
+            border-radius: 8px;
+            padding: 12px;
+            font-size: 13px;
+            max-height: 200px;
+            overflow-y: auto;
+        }
+
+        .info-panel h3 {
+            font-size: 14px;
+            color: #667eea;
+            margin-bottom: 8px;
+        }
+
+        .info-panel p {
+            margin: 4px 0;
+            color: #555;
+        }
+
+        .control-buttons {
+            display: flex;
+            gap: 10px;
+            flex-wrap: wrap;
+        }
+
+        .control-buttons .btn {
+            flex: 1;
+            min-width: 120px;
+        }
+
+        /* 文件选择器模态框 */
+        .modal {
+            display: none;
+            position: fixed;
+            z-index: 1000;
+            left: 0;
+            top: 0;
+            width: 100%;
+            height: 100%;
+            background: rgba(0, 0, 0, 0.5);
+            backdrop-filter: blur(5px);
+        }
+
+        .modal-content {
+            position: relative;
+            background: white;
+            margin: 5% auto;
+            padding: 30px;
+            width: 80%;
+            max-width: 700px;
+            border-radius: 12px;
+            box-shadow: 0 8px 32px rgba(0, 0, 0, 0.3);
+            max-height: 80vh;
+            overflow-y: auto;
+        }
+
+        .modal-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 20px;
+            padding-bottom: 15px;
+            border-bottom: 2px solid #667eea;
+        }
+
+        .modal-header h2 {
+            margin: 0;
+            color: #333;
+        }
+
+        .close-btn {
+            font-size: 28px;
+            font-weight: bold;
+            color: #999;
+            cursor: pointer;
+            transition: color 0.3s;
+        }
+
+        .close-btn:hover {
+            color: #333;
+        }
+
+        .file-list {
+            display: flex;
+            flex-direction: column;
+            gap: 10px;
+        }
+
+        .file-item {
+            padding: 15px;
+            background: #f8f9fa;
+            border-radius: 8px;
+            cursor: pointer;
+            transition: all 0.3s;
+            border: 2px solid transparent;
+        }
+
+        .file-item:hover {
+            background: #e9ecef;
+            transform: translateY(-2px);
+            box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+        }
+
+        .file-item.current {
+            border-color: #667eea;
+            background: linear-gradient(135deg, #667eea15 0%, #764ba215 100%);
+        }
+
+        .file-item-name {
+            font-weight: bold;
+            color: #333;
+            margin-bottom: 5px;
+        }
+
+        .file-item-info {
+            font-size: 12px;
+            color: #666;
+            display: flex;
+            justify-content: space-between;
+        }
+
+        .file-item-current {
+            display: inline-block;
+            background: #667eea;
+            color: white;
+            padding: 2px 8px;
+            border-radius: 4px;
+            font-size: 11px;
+            margin-left: 10px;
+        }
+
+        @media (max-width: 768px) {
+            .container {
+                flex-direction: column;
+            }
+            .sidebar {
+                width: 100%;
+                max-height: 300px;
+            }
+            .modal-content {
+                width: 95%;
+                margin: 10% auto;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <!-- 侧边栏 -->
+        <div class="sidebar">
+            <h1>🦊 记忆图可视化</h1>
+            
+            <!-- 文件选择 -->
+            <div>
+                <h2>📂 数据文件</h2>
+                <div style="display: flex; gap: 10px; margin-bottom: 10px;">
+                    <button class="btn" style="flex: 1;" onclick="showFileSelector()">选择文件</button>
+                    <button class="btn btn-secondary" style="flex: 1;" onclick="loadFileList()">刷新列表</button>
+                </div>
+                <div id="currentFileInfo" style="font-size: 12px; color: #666; padding: 8px; background: #f8f9fa; border-radius: 6px;">
+                    <p>加载中...</p>
+                </div>
+            </div>
+
+            <!-- 搜索 -->
+            <div>
+                <h2>🔍 搜索记忆</h2>
+                <div class="search-box">
+                    <input type="text" id="searchInput" placeholder="输入关键词搜索...">
+                    <button class="btn" onclick="searchMemories()">搜索</button>
+                </div>
+            </div>
+
+            <!-- 统计信息 -->
+            <div>
+                <h2>📊 统计信息</h2>
+                <div class="stats">
+                    <div class="stat-item">
+                        <div class="stat-value" id="statNodes">0</div>
+                        <div class="stat-label">节点数</div>
+                    </div>
+                    <div class="stat-item">
+                        <div class="stat-value" id="statEdges">0</div>
+                        <div class="stat-label">边数</div>
+                    </div>
+                    <div class="stat-item">
+                        <div class="stat-value" id="statMemories">0</div>
+                        <div class="stat-label">记忆数</div>
+                    </div>
+                    <div class="stat-item">
+                        <div class="stat-value" id="statDensity">0%</div>
+                        <div class="stat-label">图密度</div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- 节点类型图例 -->
+            <div>
+                <h2>🎨 节点类型</h2>
+                <div class="legend">
+                    <div class="legend-item">
+                        <div class="legend-color" style="background: #FF6B6B;"></div>
+                        <span>主体 (SUBJECT)</span>
+                    </div>
+                    <div class="legend-item">
+                        <div class="legend-color" style="background: #4ECDC4;"></div>
+                        <span>主题 (TOPIC)</span>
+                    </div>
+                    <div class="legend-item">
+                        <div class="legend-color" style="background: #45B7D1;"></div>
+                        <span>客体 (OBJECT)</span>
+                    </div>
+                    <div class="legend-item">
+                        <div class="legend-color" style="background: #FFA07A;"></div>
+                        <span>属性 (ATTRIBUTE)</span>
+                    </div>
+                    <div class="legend-item">
+                        <div class="legend-color" style="background: #98D8C8;"></div>
+                        <span>值 (VALUE)</span>
+                    </div>
+                </div>
+            </div>
+
+            <!-- 过滤器 -->
+            <div>
+                <h2>🔧 过滤器</h2>
+                <div class="filter-group">
+                    <div class="filter-item">
+                        <input type="checkbox" id="filterSubject" checked onchange="applyFilters()">
+                        <label for="filterSubject">显示主体节点</label>
+                    </div>
+                    <div class="filter-item">
+                        <input type="checkbox" id="filterTopic" checked onchange="applyFilters()">
+                        <label for="filterTopic">显示主题节点</label>
+                    </div>
+                    <div class="filter-item">
+                        <input type="checkbox" id="filterObject" checked onchange="applyFilters()">
+                        <label for="filterObject">显示客体节点</label>
+                    </div>
+                    <div class="filter-item">
+                        <input type="checkbox" id="filterAttribute" checked onchange="applyFilters()">
+                        <label for="filterAttribute">显示属性节点</label>
+                    </div>
+                    <div class="filter-item">
+                        <input type="checkbox" id="filterValue" checked onchange="applyFilters()">
+                        <label for="filterValue">显示值节点</label>
+                    </div>
+                </div>
+            </div>
+
+            <!-- 选中节点信息 -->
+            <div>
+                <h2>ℹ️ 节点信息</h2>
+                <div class="info-panel" id="nodeInfo">
+                    <p style="color: #999;">点击节点查看详细信息</p>
+                </div>
+            </div>
+        </div>
+
+        <!-- 主内容区 -->
+        <div class="main-content">
+            <!-- 控制按钮 -->
+            <div class="controls">
+                <div class="control-buttons">
+                    <button class="btn" onclick="loadGraph()">🔄 刷新图形</button>
+                    <button class="btn btn-secondary" onclick="fitNetwork()">📐 适应窗口</button>
+                    <button class="btn" onclick="exportGraph()">💾 导出数据</button>
+                </div>
+            </div>
+
+            <!-- 图形显示区 -->
+            <div class="graph-container">
+                <div id="memory-graph"></div>
+                <div class="loading" id="loading">
+                    <div class="loading-spinner"></div>
+                    <div>正在加载记忆图...</div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- 文件选择模态框 -->
+    <div id="fileModal" class="modal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h2>📂 选择数据文件</h2>
+                <span class="close-btn" onclick="closeFileSelector()">&times;</span>
+            </div>
+            <div id="fileListContainer">
+                <div style="text-align: center; padding: 20px;">
+                    <div class="loading-spinner"></div>
+                    <p>加载文件列表...</p>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        let network = null;
+        let availableFiles = [];
+        let graphData = {
+            nodes: [],
+            edges: [],
+            memories: []
+        };
+        let originalData = null;
+
+        // 节点颜色配置
+        const nodeColors = {
+            'SUBJECT': '#FF6B6B',
+            'TOPIC': '#4ECDC4',
+            'OBJECT': '#45B7D1',
+            'ATTRIBUTE': '#FFA07A',
+            'VALUE': '#98D8C8'
+        };
+
+        // 初始化图形
+        function initNetwork() {
+            const container = document.getElementById('memory-graph');
+            
+            const options = {
+                nodes: {
+                    shape: 'dot',
+                    size: 20,
+                    font: {
+                        size: 14,
+                        color: '#333',
+                        face: 'Microsoft YaHei'
+                    },
+                    borderWidth: 2,
+                    borderWidthSelected: 4,
+                    shadow: true
+                },
+                edges: {
+                    width: 2,
+                    color: {
+                        color: '#848484',
+                        highlight: '#667eea',
+                        hover: '#764ba2'
+                    },
+                    arrows: {
+                        to: {
+                            enabled: true,
+                            scaleFactor: 0.5
+                        }
+                    },
+                    smooth: {
+                        enabled: true,
+                        type: 'dynamic'
+                    },
+                    font: {
+                        size: 11,
+                        color: '#666',
+                        face: 'Microsoft YaHei',
+                        align: 'middle'
+                    }
+                },
+                physics: {
+                    enabled: true,
+                    barnesHut: {
+                        gravitationalConstant: -8000,
+                        centralGravity: 0.3,
+                        springLength: 150,
+                        springConstant: 0.04,
+                        damping: 0.09,
+                        avoidOverlap: 0.1
+                    },
+                    stabilization: {
+                        enabled: true,
+                        iterations: 300,
+                        updateInterval: 25,
+                        onlyDynamicEdges: false,
+                        fit: true
+                    },
+                    // 稳定后自动停止物理引擎
+                    solver: 'barnesHut',
+                    timestep: 0.5,
+                    adaptiveTimestep: true
+                },
+                interaction: {
+                    hover: true,
+                    tooltipDelay: 100,
+                    zoomView: true,
+                    dragView: true
+                }
+            };
+
+            const data = {
+                nodes: new vis.DataSet([]),
+                edges: new vis.DataSet([])
+            };
+
+            network = new vis.Network(container, data, options);
+
+            // 添加事件监听
+            network.on('click', function(params) {
+                if (params.nodes.length > 0) {
+                    const nodeId = params.nodes[0];
+                    showNodeInfo(nodeId);
+                    highlightConnectedNodes(nodeId);
+                } else {
+                    // 点击空白处，恢复所有节点
+                    resetNodeHighlight();
+                }
+            });
+
+            // 稳定化完成后停止物理引擎
+            network.on('stabilizationIterationsDone', function() {
+                console.log('初始稳定化完成，停止物理引擎');
+                network.setOptions({ physics: { enabled: false } });
+            });
+
+            // 添加稳定化进度监听
+            network.on('stabilizationProgress', function(params) {
+                const progress = Math.round((params.iterations / params.total) * 100);
+                if (progress % 10 === 0) { // 每10%打印一次
+                    console.log(`稳定化进度: ${progress}%`);
+                }
+            });
+        }
+
+        // 加载图形数据
+        async function loadGraph() {
+            try {
+                document.getElementById('loading').style.display = 'block';
+                
+                const response = await fetch('/api/graph/full');
+                const result = await response.json();
+
+                if (result.success) {
+                    originalData = result.data;
+                    updateGraph(result.data);
+                    updateStats(result.data.stats);
+                } else {
+                    alert('加载失败: ' + result.error);
+                }
+            } catch (error) {
+                console.error('加载图形失败:', error);
+                alert('加载失败: ' + error.message);
+            } finally {
+                document.getElementById('loading').style.display = 'none';
+            }
+        }
+
+        // 更新图形显示
+        function updateGraph(data) {
+            graphData = data;
+
+            // 处理节点数据
+            const nodes = data.nodes.map(node => ({
+                id: node.id,
+                label: node.label,
+                title: node.title,
+                group: node.group,
+                color: nodeColors[node.group] || '#999',
+                metadata: node.metadata
+            }));
+
+            // 处理边数据
+            const edges = data.edges.map(edge => ({
+                id: edge.id,
+                from: edge.from,
+                to: edge.to,
+                label: edge.label,
+                title: edge.title,
+                width: edge.importance * 3 + 1
+            }));
+
+            // 更新网络
+            network.setData({
+                nodes: new vis.DataSet(nodes),
+                edges: new vis.DataSet(edges)
+            });
+
+            // 注意：setData 会自动触发物理引擎重新布局
+            // stabilizationIterationsDone 事件监听器会自动停止物理引擎
+        }
+
+        // 更新统计信息
+        function updateStats(stats) {
+            document.getElementById('statNodes').textContent = stats.total_nodes;
+            document.getElementById('statEdges').textContent = stats.total_edges;
+            document.getElementById('statMemories').textContent = stats.total_memories;
+            
+            const density = stats.total_nodes > 0 
+                ? ((stats.total_edges / (stats.total_nodes * (stats.total_nodes - 1))) * 100).toFixed(2)
+                : 0;
+            document.getElementById('statDensity').textContent = density + '%';
+        }
+
+        // 显示节点信息
+        function showNodeInfo(nodeId) {
+            const node = graphData.nodes.find(n => n.id === nodeId);
+            if (!node) return;
+
+            const infoPanel = document.getElementById('nodeInfo');
+            infoPanel.innerHTML = `
+                <h3>${node.label}</h3>
+                <p><strong>类型:</strong> ${node.type}</p>
+                <p><strong>ID:</strong> ${node.id.substring(0, 8)}...</p>
+                <p><strong>创建时间:</strong> ${new Date(node.created_at).toLocaleString('zh-CN')}</p>
+                ${node.metadata && Object.keys(node.metadata).length > 0 
+                    ? `<p><strong>元数据:</strong> ${JSON.stringify(node.metadata, null, 2)}</p>`
+                    : ''}
+            `;
+        }
+
+        // 搜索记忆
+        async function searchMemories() {
+            const query = document.getElementById('searchInput').value;
+            if (!query) {
+                alert('请输入搜索关键词');
+                return;
+            }
+
+            try {
+                const response = await fetch(`/api/search?q=${encodeURIComponent(query)}&limit=50`);
+                const result = await response.json();
+
+                if (result.success) {
+                    highlightSearchResults(result.data.results);
+                } else {
+                    alert('搜索失败: ' + result.error);
+                }
+            } catch (error) {
+                console.error('搜索失败:', error);
+                alert('搜索失败: ' + error.message);
+            }
+        }
+
+        // 高亮搜索结果
+        function highlightSearchResults(results) {
+            const memoryIds = results.map(r => r.id);
+            const relatedNodeIds = new Set();
+
+            // 找出相关的节点
+            graphData.memories.forEach(memory => {
+                if (memoryIds.includes(memory.id)) {
+                    // 这里需要找到该记忆相关的所有节点
+                    // 简化实现：高亮所有节点
+                    graphData.nodes.forEach(node => relatedNodeIds.add(node.id));
+                }
+            });
+
+            // 高亮节点
+            if (relatedNodeIds.size > 0) {
+                network.selectNodes([...relatedNodeIds]);
+                network.fit({
+                    nodes: [...relatedNodeIds],
+                    animation: true
+                });
+            } else {
+                alert('未找到相关节点');
+            }
+        }
+
+        // 高亮与选中节点连接的节点（最多3跳深度）
+        function highlightConnectedNodes(nodeId) {
+            if (!network || !graphData) return;
+
+            // 使用 BFS 探索最多3跳深度的连接节点
+            const MAX_DEPTH = 3;
+            const connectedNodeIds = new Set();
+            const connectedEdgeIds = new Set();
+            const visited = new Set();
+            const queue = [{ nodeId: nodeId, depth: 0 }];
+
+            // 构建邻接表以提高查询效率
+            const adjacencyMap = new Map();
+            graphData.edges.forEach(edge => {
+                if (!adjacencyMap.has(edge.from)) {
+                    adjacencyMap.set(edge.from, []);
+                }
+                if (!adjacencyMap.has(edge.to)) {
+                    adjacencyMap.set(edge.to, []);
+                }
+                adjacencyMap.get(edge.from).push({ nodeId: edge.to, edgeId: edge.id });
+                adjacencyMap.get(edge.to).push({ nodeId: edge.from, edgeId: edge.id });
+            });
+
+            // BFS 遍历，限制深度为3跳
+            while (queue.length > 0) {
+                const { nodeId: currentNode, depth } = queue.shift();
+                
+                if (visited.has(currentNode)) continue;
+                visited.add(currentNode);
+                connectedNodeIds.add(currentNode);
+
+                // 如果已经达到最大深度，不再探索更深的节点
+                if (depth >= MAX_DEPTH) continue;
+
+                // 探索相邻节点
+                const neighbors = adjacencyMap.get(currentNode) || [];
+                neighbors.forEach(({ nodeId: neighborId, edgeId }) => {
+                    connectedEdgeIds.add(edgeId);
+                    if (!visited.has(neighborId)) {
+                        queue.push({ nodeId: neighborId, depth: depth + 1 });
+                    }
+                });
+            }
+
+            console.log(`选中节点: ${nodeId}, 连接的节点数: ${connectedNodeIds.size}, 连接的边数: ${connectedEdgeIds.size} (最大深度: ${MAX_DEPTH})`);
+
+            // 更新所有节点的透明度
+            const allNodes = network.body.data.nodes;
+            const allEdges = network.body.data.edges;
+            const updates = [];
+
+            allNodes.get().forEach(node => {
+                if (connectedNodeIds.has(node.id)) {
+                    // 连接的节点保持正常，甚至可以加强显示
+                    // 被选中的节点特别突出
+                    const isSelected = node.id === nodeId;
+                    updates.push({
+                        id: node.id,
+                        opacity: 1.0,
+                        borderWidth: isSelected ? 5 : 3,
+                        font: { 
+                            color: isSelected ? '#667eea' : '#333', 
+                            size: isSelected ? 16 : 14, 
+                            bold: true 
+                        }
+                    });
+                } else {
+                    // 无关节点变为高度透明
+                    const dimmedColor = hexToRgba(node.color, 0.08);
+                    updates.push({
+                        id: node.id,
+                        color: {
+                            background: dimmedColor,
+                            border: dimmedColor,
+                            highlight: { background: dimmedColor, border: dimmedColor }
+                        },
+                        opacity: 0.08,
+                        font: { color: 'rgba(51, 51, 51, 0.08)', size: 14 }
+                    });
+                }
+            });
+            allNodes.update(updates);
+
+            // 更新所有边的透明度
+            const edgeUpdates = [];
+            allEdges.get().forEach(edge => {
+                if (connectedEdgeIds.has(edge.id)) {
+                    // 连接的边加强显示
+                    edgeUpdates.push({
+                        id: edge.id,
+                        color: { color: '#667eea', opacity: 1.0 },
+                        width: 4,
+                        font: { color: '#667eea', size: 12 }
+                    });
+                } else {
+                    // 无关边变为高度透明
+                    edgeUpdates.push({
+                        id: edge.id,
+                        color: { color: '#848484', opacity: 0.03 },
+                        width: 1,
+                        font: { color: 'rgba(102, 102, 102, 0.03)', size: 11 }
+                    });
+                }
+            });
+            allEdges.update(edgeUpdates);
+
+            // 将视图聚焦到连接的子图
+            if (connectedNodeIds.size > 1 && connectedNodeIds.size < 100) {
+                network.fit({
+                    nodes: Array.from(connectedNodeIds),
+                    animation: {
+                        duration: 800,
+                        easingFunction: 'easeInOutQuad'
+                    }
+                });
+            }
+        }
+
+        // 重置节点高亮状态
+        function resetNodeHighlight() {
+            if (!network || !graphData) return;
+
+            const allNodes = network.body.data.nodes;
+            const allEdges = network.body.data.edges;
+
+            // 恢复所有节点 - 重新应用原始颜色
+            const nodeUpdates = [];
+            allNodes.get().forEach(node => {
+                const originalColor = nodeColors[node.group] || '#999';
+                nodeUpdates.push({
+                    id: node.id,
+                    color: originalColor,
+                    opacity: 1.0,
+                    borderWidth: 2,
+                    font: { color: '#333', size: 14, bold: false }
+                });
+            });
+            allNodes.update(nodeUpdates);
+
+            // 恢复所有边
+            const edgeUpdates = [];
+            allEdges.get().forEach(edge => {
+                edgeUpdates.push({
+                    id: edge.id,
+                    color: { color: '#848484', opacity: 1.0 },
+                    width: 2,
+                    font: { color: '#666', size: 11 }
+                });
+            });
+            allEdges.update(edgeUpdates);
+        }
+
+        // 辅助函数：将十六进制颜色转换为 rgba
+        function hexToRgba(hex, alpha) {
+            // 如果已经是 rgba 格式，直接返回
+            if (hex.startsWith('rgba')) return hex;
+            
+            // 处理 # 开头的十六进制
+            const r = parseInt(hex.slice(1, 3), 16);
+            const g = parseInt(hex.slice(3, 5), 16);
+            const b = parseInt(hex.slice(5, 7), 16);
+            return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+        }
+
+        // 应用过滤器
+        function applyFilters() {
+            if (!originalData) return;
+
+            const filters = {
+                'SUBJECT': document.getElementById('filterSubject').checked,
+                'TOPIC': document.getElementById('filterTopic').checked,
+                'OBJECT': document.getElementById('filterObject').checked,
+                'ATTRIBUTE': document.getElementById('filterAttribute').checked,
+                'VALUE': document.getElementById('filterValue').checked
+            };
+
+            // 过滤节点
+            const filteredNodes = originalData.nodes.filter(node => 
+                filters[node.group]
+            );
+            const filteredNodeIds = new Set(filteredNodes.map(n => n.id));
+
+            // 过滤边（只保留两端节点都存在的边）
+            const filteredEdges = originalData.edges.filter(edge =>
+                filteredNodeIds.has(edge.from) && filteredNodeIds.has(edge.to)
+            );
+
+            // 更新图形
+            updateGraph({
+                nodes: filteredNodes,
+                edges: filteredEdges,
+                memories: originalData.memories,
+                stats: {
+                    total_nodes: filteredNodes.length,
+                    total_edges: filteredEdges.length,
+                    total_memories: originalData.stats.total_memories
+                }
+            });
+
+            // 重置高亮状态
+            resetNodeHighlight();
+
+            // 重新启用物理引擎以重新布局，避免节点排版错乱
+            if (network) {
+                network.setOptions({ physics: { enabled: true } });
+                
+                // 设置超时保护，确保物理引擎最终会停止
+                let stabilized = false;
+                const stabilizationTimeout = setTimeout(() => {
+                    if (!stabilized) {
+                        console.log('物理引擎稳定超时，强制停止');
+                        network.setOptions({ physics: { enabled: false } });
+                    }
+                }, 5000); // 5秒超时
+
+                // 等待稳定后再禁用物理引擎
+                network.once('stabilizationIterationsDone', function() {
+                    stabilized = true;
+                    clearTimeout(stabilizationTimeout);
+                    network.setOptions({ physics: { enabled: false } });
+                    console.log('物理引擎已稳定并停止');
+                });
+            }
+        }
+
+        // 适应窗口
+        function fitNetwork() {
+            if (network) {
+                network.fit({
+                    animation: {
+                        duration: 1000,
+                        easingFunction: 'easeInOutQuad'
+                    }
+                });
+            }
+        }
+
+        // 导出图形数据
+        function exportGraph() {
+            const dataStr = JSON.stringify(graphData, null, 2);
+            const dataBlob = new Blob([dataStr], { type: 'application/json' });
+            const url = URL.createObjectURL(dataBlob);
+            const link = document.createElement('a');
+            link.href = url;
+            link.download = `memory_graph_${new Date().getTime()}.json`;
+            link.click();
+            URL.revokeObjectURL(url);
+        }
+
+        // 文件选择功能
+        async function loadFileList() {
+            try {
+                const response = await fetch('/api/files');
+                const result = await response.json();
+
+                if (result.success) {
+                    availableFiles = result.files;
+                    updateCurrentFileInfo(result.current_file, result.files);
+                    return result.files;
+                } else {
+                    console.error('加载文件列表失败:', result.error);
+                    return [];
+                }
+            } catch (error) {
+                console.error('加载文件列表失败:', error);
+                return [];
+            }
+        }
+
+        function updateCurrentFileInfo(currentFile, files) {
+            const infoDiv = document.getElementById('currentFileInfo');
+            
+            if (!currentFile || files.length === 0) {
+                infoDiv.innerHTML = '<p style="color: #e74c3c;">❌ 未找到数据文件</p>';
+                return;
+            }
+
+            const currentFileObj = files.find(f => f.path === currentFile);
+            if (currentFileObj) {
+                infoDiv.innerHTML = `
+                    <div style="margin-bottom: 5px;"><strong>📄 ${currentFileObj.name}</strong></div>
+                    <div style="display: flex; justify-content: space-between;">
+                        <span>大小: ${currentFileObj.size_kb} KB</span>
+                        <span>修改: ${currentFileObj.modified_readable.split(' ')[0]}</span>
+                    </div>
+                `;
+            }
+        }
+
+        async function showFileSelector() {
+            const modal = document.getElementById('fileModal');
+            const container = document.getElementById('fileListContainer');
+            
+            modal.style.display = 'block';
+            container.innerHTML = `
+                <div style="text-align: center; padding: 20px;">
+                    <div class="loading-spinner"></div>
+                    <p>加载文件列表...</p>
+                </div>
+            `;
+
+            const files = await loadFileList();
+
+            if (files.length === 0) {
+                container.innerHTML = `
+                    <div style="text-align: center; padding: 40px; color: #999;">
+                        <p style="font-size: 48px; margin-bottom: 10px;">📭</p>
+                        <p>未找到任何数据文件</p>
+                        <p style="font-size: 12px; margin-top: 10px;">请先运行Bot生成记忆数据</p>
+                    </div>
+                `;
+                return;
+            }
+
+            let html = '<div class="file-list">';
+            files.forEach(file => {
+                const currentBadge = file.is_current ? '<span class="file-item-current">当前</span>' : '';
+                html += `
+                    <div class="file-item ${file.is_current ? 'current' : ''}" onclick="selectFile('${file.path.replace(/\\/g, '\\\\')}')">
+                        <div class="file-item-name">📄 ${file.name}${currentBadge}</div>
+                        <div class="file-item-info">
+                            <span>大小: ${file.size_kb} KB</span>
+                            <span>${file.modified_readable}</span>
+                        </div>
+                    </div>
+                `;
+            });
+            html += '</div>';
+
+            container.innerHTML = html;
+        }
+
+        function closeFileSelector() {
+            document.getElementById('fileModal').style.display = 'none';
+        }
+
+        async function selectFile(filePath) {
+            try {
+                document.getElementById('loading').style.display = 'block';
+                closeFileSelector();
+
+                const response = await fetch('/api/select_file', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({ file_path: filePath })
+                });
+
+                const result = await response.json();
+
+                if (result.success) {
+                    // 重新加载图形
+                    await loadGraph();
+                    await loadFileList();
+                    alert('✅ ' + result.message);
+                } else {
+                    alert('❌ 切换文件失败: ' + result.error);
+                }
+            } catch (error) {
+                console.error('切换文件失败:', error);
+                alert('❌ 切换文件失败: ' + error.message);
+            } finally {
+                document.getElementById('loading').style.display = 'none';
+            }
+        }
+
+        // 点击模态框外部关闭
+        window.onclick = function(event) {
+            const modal = document.getElementById('fileModal');
+            if (event.target == modal) {
+                closeFileSelector();
+            }
+        }
+
+        // 页面加载完成后初始化
+        window.addEventListener('load', function() {
+            initNetwork();
+            loadGraph();
+            loadFileList();
+        });
+    </script>
+</body>
+</html>
diff --git a/tools/memory_visualizer/visualizer.ps1 b/tools/memory_visualizer/visualizer.ps1
new file mode 100644
index 000000000..9d02a9a50
--- /dev/null
+++ b/tools/memory_visualizer/visualizer.ps1
@@ -0,0 +1,59 @@
+# 记忆图可视化工具统一启动脚本
+param(
+    [switch]$Simple,
+    [switch]$Full,
+    [switch]$Generate,
+    [switch]$Test
+)
+
+$ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+$ProjectRoot = Split-Path -Parent (Split-Path -Parent $ScriptDir)
+Set-Location $ProjectRoot
+
+function Get-Python {
+    $paths = @(".venv\Scripts\python.exe", "venv\Scripts\python.exe")
+    foreach ($p in $paths) {
+        if (Test-Path $p) { return $p }
+    }
+    return $null
+}
+
+$python = Get-Python
+if (-not $python) {
+    Write-Host "ERROR: Virtual environment not found" -ForegroundColor Red
+    exit 1
+}
+
+if ($Simple) {
+    Write-Host "Starting Simple Server on http://127.0.0.1:5001" -ForegroundColor Green
+    & $python "$ScriptDir\visualizer_simple.py"
+}
+elseif ($Full) {
+    Write-Host "Starting Full Server on http://127.0.0.1:5000" -ForegroundColor Green
+    & $python "$ScriptDir\visualizer_server.py"
+}
+elseif ($Generate) {
+    & $python "$ScriptDir\generate_sample_data.py"
+}
+elseif ($Test) {
+    & $python "$ScriptDir\test_visualizer.py"
+}
+else {
+    Write-Host "MoFox Bot - Memory Graph Visualizer" -ForegroundColor Cyan
+    Write-Host ""
+    Write-Host "[1] Start Simple Server (Recommended)"
+    Write-Host "[2] Start Full Server"
+    Write-Host "[3] Generate Test Data"
+    Write-Host "[4] Run Tests"
+    Write-Host "[Q] Quit"
+    Write-Host ""
+    $choice = Read-Host "Select"
+    
+    switch ($choice) {
+        "1" { & $python "$ScriptDir\visualizer_simple.py" }
+        "2" { & $python "$ScriptDir\visualizer_server.py" }
+        "3" { & $python "$ScriptDir\generate_sample_data.py" }
+        "4" { & $python "$ScriptDir\test_visualizer.py" }
+        default { exit 0 }
+    }
+}
diff --git a/tools/memory_visualizer/visualizer_server.py b/tools/memory_visualizer/visualizer_server.py
new file mode 100644
index 000000000..7b606e200
--- /dev/null
+++ b/tools/memory_visualizer/visualizer_server.py
@@ -0,0 +1,356 @@
+"""
+记忆图可视化服务器
+
+提供 Web API 用于可视化记忆图数据
+"""
+
+import asyncio
+import json
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from flask import Flask, jsonify, render_template, request
+from flask_cors import CORS
+
+# 添加项目根目录到 Python 路径
+import sys
+project_root = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from src.memory_graph.manager import MemoryManager
+from src.memory_graph.models import EdgeType, MemoryType, NodeType
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = Flask(__name__)
+CORS(app)  # 允许跨域请求
+
+# 全局记忆管理器
+memory_manager: Optional[MemoryManager] = None
+
+
+def init_memory_manager():
+    """初始化记忆管理器"""
+    global memory_manager
+    if memory_manager is None:
+        try:
+            memory_manager = MemoryManager()
+            # 在新的事件循环中初始化
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            loop.run_until_complete(memory_manager.initialize())
+            logger.info("记忆管理器初始化成功")
+        except Exception as e:
+            logger.error(f"初始化记忆管理器失败: {e}")
+            raise
+
+
+@app.route('/')
+def index():
+    """主页面"""
+    return render_template('visualizer.html')
+
+
+@app.route('/api/graph/full')
+def get_full_graph():
+    """
+    获取完整记忆图数据
+    
+    返回所有节点和边，格式化为前端可用的结构
+    """
+    try:
+        if memory_manager is None:
+            init_memory_manager()
+        
+        # 获取所有记忆
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        
+        # 获取所有记忆
+        all_memories = memory_manager.graph_store.get_all_memories()
+        
+        # 构建节点和边数据
+        nodes_dict = {}  # {node_id: node_data}
+        edges_dict = {}  # {edge_id: edge_data} - 使用字典去重
+        memory_info = []
+        
+        for memory in all_memories:
+            # 添加记忆信息
+            memory_info.append({
+                'id': memory.id,
+                'type': memory.memory_type.value,
+                'importance': memory.importance,
+                'activation': memory.activation,
+                'status': memory.status.value,
+                'created_at': memory.created_at.isoformat(),
+                'text': memory.to_text(),
+                'access_count': memory.access_count,
+            })
+            
+            # 处理节点
+            for node in memory.nodes:
+                if node.id not in nodes_dict:
+                    nodes_dict[node.id] = {
+                        'id': node.id,
+                        'label': node.content,
+                        'type': node.node_type.value,
+                        'group': node.node_type.name,  # 用于颜色分组
+                        'title': f"{node.node_type.value}: {node.content}",
+                        'metadata': node.metadata,
+                        'created_at': node.created_at.isoformat(),
+                    }
+            
+            # 处理边 - 使用字典自动去重
+            for edge in memory.edges:
+                edge_id = edge.id
+                # 如果ID已存在，生成唯一ID
+                counter = 1
+                original_edge_id = edge_id
+                while edge_id in edges_dict:
+                    edge_id = f"{original_edge_id}_{counter}"
+                    counter += 1
+                
+                edges_dict[edge_id] = {
+                    'id': edge_id,
+                    'from': edge.source_id,
+                    'to': edge.target_id,
+                    'label': edge.relation,
+                    'type': edge.edge_type.value,
+                    'importance': edge.importance,
+                    'title': f"{edge.edge_type.value}: {edge.relation}",
+                    'arrows': 'to',
+                    'memory_id': memory.id,
+                }
+        
+        nodes_list = list(nodes_dict.values())
+        edges_list = list(edges_dict.values())
+        
+        return jsonify({
+            'success': True,
+            'data': {
+                'nodes': nodes_list,
+                'edges': edges_list,
+                'memories': memory_info,
+                'stats': {
+                    'total_nodes': len(nodes_list),
+                    'total_edges': len(edges_list),
+                    'total_memories': len(all_memories),
+                }
+            }
+        })
+    
+    except Exception as e:
+        logger.error(f"获取图数据失败: {e}", exc_info=True)
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+
+@app.route('/api/memory/<memory_id>')
+def get_memory_detail(memory_id: str):
+    """
+    获取特定记忆的详细信息
+    
+    Args:
+        memory_id: 记忆ID
+    """
+    try:
+        if memory_manager is None:
+            init_memory_manager()
+        
+        memory = memory_manager.graph_store.get_memory_by_id(memory_id)
+        
+        if memory is None:
+            return jsonify({
+                'success': False,
+                'error': '记忆不存在'
+            }), 404
+        
+        return jsonify({
+            'success': True,
+            'data': memory.to_dict()
+        })
+    
+    except Exception as e:
+        logger.error(f"获取记忆详情失败: {e}", exc_info=True)
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+
+@app.route('/api/search')
+def search_memories():
+    """
+    搜索记忆
+    
+    Query参数:
+        - q: 搜索关键词
+        - type: 记忆类型过滤
+        - limit: 返回数量限制
+    """
+    try:
+        if memory_manager is None:
+            init_memory_manager()
+        
+        query = request.args.get('q', '')
+        memory_type = request.args.get('type', None)
+        limit = int(request.args.get('limit', 50))
+        
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        
+        # 执行搜索
+        results = loop.run_until_complete(
+            memory_manager.search_memories(
+                query=query,
+                top_k=limit
+            )
+        )
+        
+        # 构建返回数据
+        memories = []
+        for memory in results:
+            memories.append({
+                'id': memory.id,
+                'text': memory.to_text(),
+                'type': memory.memory_type.value,
+                'importance': memory.importance,
+                'created_at': memory.created_at.isoformat(),
+            })
+        
+        return jsonify({
+            'success': True,
+            'data': {
+                'results': memories,
+                'count': len(memories),
+            }
+        })
+    
+    except Exception as e:
+        logger.error(f"搜索失败: {e}", exc_info=True)
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+
+@app.route('/api/stats')
+def get_statistics():
+    """
+    获取记忆图统计信息
+    """
+    try:
+        if memory_manager is None:
+            init_memory_manager()
+        
+        # 获取统计信息
+        all_memories = memory_manager.graph_store.get_all_memories()
+        all_nodes = set()
+        all_edges = 0
+        
+        for memory in all_memories:
+            for node in memory.nodes:
+                all_nodes.add(node.id)
+            all_edges += len(memory.edges)
+        
+        stats = {
+            'total_memories': len(all_memories),
+            'total_nodes': len(all_nodes),
+            'total_edges': all_edges,
+            'node_types': {},
+            'memory_types': {},
+        }
+        
+        # 统计节点类型分布
+        for memory in all_memories:
+            mem_type = memory.memory_type.value
+            stats['memory_types'][mem_type] = stats['memory_types'].get(mem_type, 0) + 1
+            
+            for node in memory.nodes:
+                node_type = node.node_type.value
+                stats['node_types'][node_type] = stats['node_types'].get(node_type, 0) + 1
+        
+        return jsonify({
+            'success': True,
+            'data': stats
+        })
+    
+    except Exception as e:
+        logger.error(f"获取统计信息失败: {e}", exc_info=True)
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+
+@app.route('/api/files')
+def list_files():
+    """
+    列出所有可用的数据文件
+    注意: 完整版服务器直接使用内存中的数据，不支持文件切换
+    """
+    try:
+        from pathlib import Path
+        data_dir = Path("data/memory_graph")
+        
+        files = []
+        if data_dir.exists():
+            for f in data_dir.glob("*.json"):
+                stat = f.stat()
+                files.append({
+                    'path': str(f),
+                    'name': f.name,
+                    'size': stat.st_size,
+                    'size_kb': round(stat.st_size / 1024, 2),
+                    'modified': datetime.fromtimestamp(stat.st_mtime).isoformat(),
+                    'modified_readable': datetime.fromtimestamp(stat.st_mtime).strftime('%Y-%m-%d %H:%M:%S'),
+                    'is_current': True  # 完整版始终使用内存数据
+                })
+        
+        return jsonify({
+            'success': True,
+            'files': files,
+            'count': len(files),
+            'current_file': 'memory_manager (实时数据)',
+            'note': '完整版服务器使用实时内存数据，如需切换文件请使用独立版服务器'
+        })
+    except Exception as e:
+        logger.error(f"获取文件列表失败: {e}", exc_info=True)
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+
+@app.route('/api/reload')
+def reload_data():
+    """
+    重新加载数据
+    """
+    return jsonify({
+        'success': True,
+        'message': '完整版服务器使用实时数据，无需重新加载',
+        'note': '数据始终是最新的'
+    })
+
+
+def run_server(host: str = '127.0.0.1', port: int = 5000, debug: bool = False):
+    """
+    启动可视化服务器
+    
+    Args:
+        host: 服务器地址
+        port: 端口号
+        debug: 是否开启调试模式
+    """
+    logger.info(f"启动记忆图可视化服务器: http://{host}:{port}")
+    app.run(host=host, port=port, debug=debug)
+
+
+if __name__ == '__main__':
+    run_server(debug=True)
diff --git a/tools/memory_visualizer/visualizer_simple.py b/tools/memory_visualizer/visualizer_simple.py
new file mode 100644
index 000000000..d43b490d0
--- /dev/null
+++ b/tools/memory_visualizer/visualizer_simple.py
@@ -0,0 +1,480 @@
+"""
+记忆图可视化 - 独立版本
+
+直接从存储的数据文件生成可视化,无需启动完整的记忆管理器
+"""
+
+import json
+import sys
+from pathlib import Path
+from datetime import datetime
+from typing import Any, Dict, List, Set
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set
+
+# 添加项目根目录
+project_root = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from flask import Flask, jsonify, render_template_string, request, send_from_directory
+from flask_cors import CORS
+
+app = Flask(__name__)
+CORS(app)
+
+# 数据缓存
+graph_data_cache = None
+data_dir = project_root / "data" / "memory_graph"
+current_data_file = None  # 当前选择的数据文件
+
+
+def find_available_data_files() -> List[Path]:
+    """查找所有可用的记忆图数据文件"""
+    files = []
+    
+    if not data_dir.exists():
+        return files
+    
+    # 查找多种可能的文件名
+    possible_files = [
+        "graph_store.json",
+        "memory_graph.json",
+        "graph_data.json",
+    ]
+    
+    for filename in possible_files:
+        file_path = data_dir / filename
+        if file_path.exists():
+            files.append(file_path)
+    
+    # 查找所有备份文件
+    for pattern in ["graph_store_*.json", "memory_graph_*.json", "graph_data_*.json"]:
+        for backup_file in data_dir.glob(pattern):
+            if backup_file not in files:
+                files.append(backup_file)
+    
+    # 查找backups子目录
+    backups_dir = data_dir / "backups"
+    if backups_dir.exists():
+        for backup_file in backups_dir.glob("**/*.json"):
+            if backup_file not in files:
+                files.append(backup_file)
+    
+    # 查找data/backup目录
+    backup_dir = data_dir.parent / "backup"
+    if backup_dir.exists():
+        for backup_file in backup_dir.glob("**/graph_*.json"):
+            if backup_file not in files:
+                files.append(backup_file)
+        for backup_file in backup_dir.glob("**/memory_*.json"):
+            if backup_file not in files:
+                files.append(backup_file)
+    
+    return sorted(files, key=lambda f: f.stat().st_mtime, reverse=True)
+
+
+def load_graph_data(file_path: Optional[Path] = None) -> Dict[str, Any]:
+    """从磁盘加载图数据"""
+    global graph_data_cache, current_data_file
+    
+    # 如果指定了新文件，清除缓存
+    if file_path is not None and file_path != current_data_file:
+        graph_data_cache = None
+        current_data_file = file_path
+    
+    if graph_data_cache is not None:
+        return graph_data_cache
+    
+    try:
+        # 确定要加载的文件
+        if current_data_file is not None:
+            graph_file = current_data_file
+        else:
+            # 尝试查找可用的数据文件
+            available_files = find_available_data_files()
+            if not available_files:
+                print(f"⚠️  未找到任何图数据文件")
+                print(f"📂 搜索目录: {data_dir}")
+                return {
+                    "nodes": [], 
+                    "edges": [], 
+                    "memories": [],
+                    "stats": {"total_nodes": 0, "total_edges": 0, "total_memories": 0},
+                    "error": "未找到数据文件",
+                    "available_files": []
+                }
+            
+            # 使用最新的文件
+            graph_file = available_files[0]
+            current_data_file = graph_file
+            print(f"📂 自动选择最新文件: {graph_file}")
+        
+        if not graph_file.exists():
+            print(f"⚠️  图数据文件不存在: {graph_file}")
+            return {
+                "nodes": [], 
+                "edges": [], 
+                "memories": [],
+                "stats": {"total_nodes": 0, "total_edges": 0, "total_memories": 0},
+                "error": f"文件不存在: {graph_file}"
+            }
+        
+        print(f"📂 加载图数据: {graph_file}")
+        with open(graph_file, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        # 解析数据
+        nodes_dict = {}
+        edges_list = []
+        memory_info = []
+        
+        # 实际文件格式是 {nodes: [], edges: [], metadata: {}}
+        # 不是 {memories: [{nodes: [], edges: []}]}
+        nodes = data.get("nodes", [])
+        edges = data.get("edges", [])
+        metadata = data.get("metadata", {})
+        
+        print(f"✅ 找到 {len(nodes)} 个节点, {len(edges)} 条边")
+        
+        # 处理节点
+        for node in nodes:
+            node_id = node.get('id', '')
+            if node_id and node_id not in nodes_dict:
+                memory_ids = node.get('metadata', {}).get('memory_ids', [])
+                nodes_dict[node_id] = {
+                    'id': node_id,
+                    'label': node.get('content', ''),
+                    'type': node.get('node_type', ''),
+                    'group': extract_group_from_type(node.get('node_type', '')),
+                    'title': f"{node.get('node_type', '')}: {node.get('content', '')}",
+                    'metadata': node.get('metadata', {}),
+                    'created_at': node.get('created_at', ''),
+                    'memory_ids': memory_ids,
+                }
+        
+        # 处理边 - 使用集合去重，避免重复的边ID
+        existing_edge_ids = set()
+        for edge in edges:
+            # 边的ID字段可能是 'id' 或 'edge_id'
+            edge_id = edge.get('edge_id') or edge.get('id', '')
+            # 如果ID为空或已存在，跳过这条边
+            if not edge_id or edge_id in existing_edge_ids:
+                continue
+            
+            existing_edge_ids.add(edge_id)
+            memory_id = edge.get('metadata', {}).get('memory_id', '')
+            
+            # 注意: GraphStore 保存的格式使用 'source'/'target', 不是 'source_id'/'target_id'
+            edges_list.append({
+                'id': edge_id,
+                'from': edge.get('source', edge.get('source_id', '')),
+                'to': edge.get('target', edge.get('target_id', '')),
+                'label': edge.get('relation', ''),
+                'type': edge.get('edge_type', ''),
+                'importance': edge.get('importance', 0.5),
+                'title': f"{edge.get('edge_type', '')}: {edge.get('relation', '')}",
+                'arrows': 'to',
+                'memory_id': memory_id,
+            })
+        
+        # 从元数据中获取统计信息
+        stats = metadata.get('statistics', {})
+        total_memories = stats.get('total_memories', 0)
+        
+        # TODO: 如果需要记忆详细信息,需要从其他地方加载
+        # 目前只有节点和边的数据
+        
+        graph_data_cache = {
+            'nodes': list(nodes_dict.values()),
+            'edges': edges_list,
+            'memories': memory_info,  # 空列表,因为文件中没有记忆详情
+            'stats': {
+                'total_nodes': len(nodes_dict),
+                'total_edges': len(edges_list),
+                'total_memories': total_memories,
+            },
+            'current_file': str(graph_file),
+            'file_size': graph_file.stat().st_size,
+            'file_modified': datetime.fromtimestamp(graph_file.stat().st_mtime).isoformat(),
+        }
+        
+        print(f"📊 统计: {len(nodes_dict)} 个节点, {len(edges_list)} 条边, {total_memories} 条记忆")
+        print(f"📄 数据文件: {graph_file} ({graph_file.stat().st_size / 1024:.2f} KB)")
+        return graph_data_cache
+        
+    except Exception as e:
+        print(f"❌ 加载失败: {e}")
+        import traceback
+        traceback.print_exc()
+        return {"nodes": [], "edges": [], "memories": [], "stats": {}}
+
+
+def extract_group_from_type(node_type: str) -> str:
+    """从节点类型提取分组名"""
+    # 假设类型格式为 "主体" 或 "SUBJECT"
+    type_mapping = {
+        '主体': 'SUBJECT',
+        '主题': 'TOPIC',
+        '客体': 'OBJECT',
+        '属性': 'ATTRIBUTE',
+        '值': 'VALUE',
+    }
+    return type_mapping.get(node_type, node_type)
+
+
+def generate_memory_text(memory: Dict[str, Any]) -> str:
+    """生成记忆的文本描述"""
+    try:
+        nodes = {n['id']: n for n in memory.get('nodes', [])}
+        edges = memory.get('edges', [])
+        
+        subject_id = memory.get('subject_id', '')
+        if not subject_id or subject_id not in nodes:
+            return f"[记忆 {memory.get('id', '')[:8]}]"
+        
+        parts = [nodes[subject_id]['content']]
+        
+        # 找主题节点
+        for edge in edges:
+            if edge.get('edge_type') == '记忆类型' and edge.get('source_id') == subject_id:
+                topic_id = edge.get('target_id', '')
+                if topic_id in nodes:
+                    parts.append(nodes[topic_id]['content'])
+                    
+                    # 找客体
+                    for e2 in edges:
+                        if e2.get('edge_type') == '核心关系' and e2.get('source_id') == topic_id:
+                            obj_id = e2.get('target_id', '')
+                            if obj_id in nodes:
+                                parts.append(f"{e2.get('relation', '')} {nodes[obj_id]['content']}")
+                                break
+                    break
+        
+        return " ".join(parts)
+    except Exception:
+        return f"[记忆 {memory.get('id', '')[:8]}]"
+
+
+# 使用内嵌的HTML模板(与之前相同)
+HTML_TEMPLATE = open(project_root / "tools" / "memory_visualizer" / "templates" / "visualizer.html", 'r', encoding='utf-8').read()
+
+
+@app.route('/')
+def index():
+    """主页面"""
+    return render_template_string(HTML_TEMPLATE)
+
+
+@app.route('/api/graph/full')
+def get_full_graph():
+    """获取完整记忆图数据"""
+    try:
+        data = load_graph_data()
+        return jsonify({
+            'success': True,
+            'data': data
+        })
+    except Exception as e:
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+
+@app.route('/api/memory/<memory_id>')
+def get_memory_detail(memory_id: str):
+    """获取记忆详情"""
+    try:
+        data = load_graph_data()
+        memory = next((m for m in data['memories'] if m['id'] == memory_id), None)
+        
+        if memory is None:
+            return jsonify({
+                'success': False,
+                'error': '记忆不存在'
+            }), 404
+        
+        return jsonify({
+            'success': True,
+            'data': memory
+        })
+    except Exception as e:
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+
+@app.route('/api/search')
+def search_memories():
+    """搜索记忆"""
+    try:
+        query = request.args.get('q', '').lower()
+        limit = int(request.args.get('limit', 50))
+        
+        data = load_graph_data()
+        
+        # 简单的文本匹配搜索
+        results = []
+        for memory in data['memories']:
+            text = memory.get('text', '').lower()
+            if query in text:
+                results.append(memory)
+        
+        return jsonify({
+            'success': True,
+            'data': {
+                'results': results[:limit],
+                'count': len(results),
+            }
+        })
+    except Exception as e:
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+
+@app.route('/api/stats')
+def get_statistics():
+    """获取统计信息"""
+    try:
+        data = load_graph_data()
+        
+        # 扩展统计信息
+        node_types = {}
+        memory_types = {}
+        
+        for node in data['nodes']:
+            node_type = node.get('type', 'Unknown')
+            node_types[node_type] = node_types.get(node_type, 0) + 1
+        
+        for memory in data['memories']:
+            mem_type = memory.get('type', 'Unknown')
+            memory_types[mem_type] = memory_types.get(mem_type, 0) + 1
+        
+        stats = data.get('stats', {})
+        stats['node_types'] = node_types
+        stats['memory_types'] = memory_types
+        
+        return jsonify({
+            'success': True,
+            'data': stats
+        })
+    except Exception as e:
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+
+@app.route('/api/reload')
+def reload_data():
+    """重新加载数据"""
+    global graph_data_cache
+    graph_data_cache = None
+    data = load_graph_data()
+    return jsonify({
+        'success': True,
+        'message': '数据已重新加载',
+        'stats': data.get('stats', {})
+    })
+
+
+@app.route('/api/files')
+def list_files():
+    """列出所有可用的数据文件"""
+    try:
+        files = find_available_data_files()
+        file_list = []
+        
+        for f in files:
+            stat = f.stat()
+            file_list.append({
+                'path': str(f),
+                'name': f.name,
+                'size': stat.st_size,
+                'size_kb': round(stat.st_size / 1024, 2),
+                'modified': datetime.fromtimestamp(stat.st_mtime).isoformat(),
+                'modified_readable': datetime.fromtimestamp(stat.st_mtime).strftime('%Y-%m-%d %H:%M:%S'),
+                'is_current': str(f) == str(current_data_file) if current_data_file else False
+            })
+        
+        return jsonify({
+            'success': True,
+            'files': file_list,
+            'count': len(file_list),
+            'current_file': str(current_data_file) if current_data_file else None
+        })
+    except Exception as e:
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+
+@app.route('/api/select_file', methods=['POST'])
+def select_file():
+    """选择要加载的数据文件"""
+    global graph_data_cache, current_data_file
+    
+    try:
+        data = request.get_json()
+        file_path = data.get('file_path')
+        
+        if not file_path:
+            return jsonify({
+                'success': False,
+                'error': '未提供文件路径'
+            }), 400
+        
+        file_path = Path(file_path)
+        if not file_path.exists():
+            return jsonify({
+                'success': False,
+                'error': f'文件不存在: {file_path}'
+            }), 404
+        
+        # 清除缓存并加载新文件
+        graph_data_cache = None
+        current_data_file = file_path
+        graph_data = load_graph_data(file_path)
+        
+        return jsonify({
+            'success': True,
+            'message': f'已切换到文件: {file_path.name}',
+            'stats': graph_data.get('stats', {})
+        })
+    except Exception as e:
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+
+def run_server(host: str = '127.0.0.1', port: int = 5001, debug: bool = False):
+    """启动服务器"""
+    print("=" * 60)
+    print("🦊 MoFox Bot - 记忆图可视化工具 (独立版)")
+    print("=" * 60)
+    print(f"📂 数据目录: {data_dir}")
+    print(f"🌐 访问地址: http://{host}:{port}")
+    print("⏹️  按 Ctrl+C 停止服务器")
+    print("=" * 60)
+    print()
+    
+    # 预加载数据
+    load_graph_data()
+    
+    app.run(host=host, port=port, debug=debug)
+
+
+if __name__ == '__main__':
+    try:
+        run_server(debug=True)
+    except KeyboardInterrupt:
+        print("\n\n👋 服务器已停止")
+    except Exception as e:
+        print(f"\n❌ 启动失败: {e}")
+        sys.exit(1)
diff --git a/visualizer.ps1 b/visualizer.ps1
new file mode 100644
index 000000000..c63e83956
--- /dev/null
+++ b/visualizer.ps1
@@ -0,0 +1,16 @@
+#!/usr/bin/env pwsh
+# ======================================================================
+# 记忆图可视化工具 - 快捷启动脚本
+# ======================================================================
+# 此脚本是快捷方式，实际脚本位于 tools/memory_visualizer/ 目录
+# ======================================================================
+
+$visualizerScript = Join-Path $PSScriptRoot "tools\memory_visualizer\visualizer.ps1"
+
+if (Test-Path $visualizerScript) {
+    & $visualizerScript @args
+} else {
+    Write-Host "❌ 错误：找不到可视化工具脚本" -ForegroundColor Red
+    Write-Host "   预期位置: $visualizerScript" -ForegroundColor Yellow
+    exit 1
+}