Initial commit

.env

@@ -0,0 +1,2 @@
+TAVILY_API_KEY="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"
+# NOMIC_API_KEY="nk-kt4Tu3UdwFpIlDdxLcd9AK3a7cfdAKhoXvPbJ78oVlE"

COLAB_FILES_SUMMARY.md

@@ -0,0 +1,305 @@
+# 📦 Google Colab GPU测试文件总结
+
+## ✅ 已创建的文件
+
+| 文件名 | 类型 | 用途 | 推荐度 |
+|--------|------|------|--------|
+| **colab_gpu_demo.ipynb** | Jupyter Notebook | 完整的交互式GPU测试 | ⭐⭐⭐⭐⭐ |
+| **colab_quick_test.py** | Python脚本 | 一键快速GPU测试 | ⭐⭐⭐⭐⭐ |
+| **colab_gpu_test.py** | Python脚本 | 模块化GPU测试工具 | ⭐⭐⭐⭐ |
+| **COLAB_GPU_GUIDE.md** | 文档 | 详细使用指南 | ⭐⭐⭐⭐⭐ |
+
+---
+
+## 🚀 快速开始（3种方式）
+
+### 方式1: Notebook交互式测试 ⭐推荐
+
+**适合**: 第一次使用，想要详细了解每个步骤
+
+```bash
+# 步骤1: 上传文件
+上传 colab_gpu_demo.ipynb 到 Google Colab
+
+# 步骤2: 启用GPU
+运行时 → 更改运行时类型 → GPU
+
+# 步骤3: 运行
+运行时 → 全部运行
+```
+
+**优势**:
+- ✅ 可视化输出
+- ✅ 分步执行，易于理解
+- ✅ 支持实时修改
+- ✅ Markdown说明清晰
+
+---
+
+### 方式2: 快速一键测试 ⭐最快
+
+**适合**: 快速验证GPU性能
+
+```python
+# 在Colab新建笔记本，运行以下代码：
+
+# 1. 启用GPU (运行时 → GPU)
+
+# 2. 复制并运行
+!wget https://your-repo/colab_quick_test.py
+!python colab_quick_test.py
+
+# 或直接复制代码到单元格运行
+```
+
+**优势**:
+- ✅ 零配置
+- ✅ 自动安装依赖
+- ✅ 5分钟完成全部测试
+- ✅ 一次性输出完整报告
+
+---
+
+### 方式3: 模块化测试工具
+
+**适合**: 开发者深度定制
+
+```python
+# 在Colab中
+!wget https://your-repo/colab_gpu_test.py
+!python colab_gpu_test.py
+```
+
+**优势**:
+- ✅ 代码结构清晰
+- ✅ 易于扩展
+- ✅ 可集成到其他项目
+
+---
+
+## 📊 测试内容对比
+
+| 测试项目 | Notebook | Quick Test | GPU Test |
+|---------|----------|------------|----------|
+| GPU环境检测 | ✅ | ✅ | ✅ |
+| 矩阵运算测试 | ✅ | ✅ | ✅ |
+| 文本嵌入测试 | ✅ | ✅ | ✅ |
+| GraphRAG组件 | ✅ | ❌ | ❌ |
+| 显存监控 | ✅ | ✅ | ✅ |
+| 性能报告 | ✅ | ✅ | ✅ |
+| 交互式说明 | ✅ | ❌ | ❌ |
+| nvidia-smi | ✅ | ✅ | ✅ |
+
+---
+
+## 🎯 使用场景推荐
+
+### 场景1: 首次测试GPU
+**推荐**: `colab_gpu_demo.ipynb`
+- 详细的说明文档
+- 分步执行，便于学习
+- 可视化效果好
+
+### 场景2: 快速验证性能
+**推荐**: `colab_quick_test.py`
+- 一键运行
+- 5分钟得到结果
+- 完整性能报告
+
+### 场景3: 集成到CI/CD
+**推荐**: `colab_gpu_test.py`
+- 模块化设计
+- 易于自动化
+- 返回标准化结果
+
+### 场景4: 学习GPU优化
+**推荐**: `COLAB_GPU_GUIDE.md` + `colab_gpu_demo.ipynb`
+- 理论+实践
+- 详细的性能分析
+- 优化建议
+
+---
+
+## 📈 预期性能提升
+
+### Google Colab T4 GPU (免费版)
+
+| 任务 | CPU | GPU | 加速比 |
+|------|-----|-----|--------|
+| 矩阵运算 (5000x5000) | 8秒 | 0.3秒 | **25x** |
+| 文本嵌入 (1000条) | 35秒 | 6秒 | **6x** |
+| GraphRAG索引 (100文档) | 15分钟 | 4分钟 | **3.8x** |
+
+### Google Colab A100 GPU (Pro版)
+
+| 任务 | CPU | GPU | 加速比 |
+|------|-----|-----|--------|
+| 矩阵运算 | 8秒 | 0.2秒 | **40x** |
+| 文本嵌入 | 35秒 | 3秒 | **12x** |
+| GraphRAG索引 | 15分钟 | 2.5分钟 | **6x** |
+
+---
+
+## 🔧 完整GraphRAG部署流程
+
+### 步骤1: GPU性能测试
+```python
+# 运行quick test验证GPU
+!python colab_quick_test.py
+```
+
+### 步骤2: 上传项目文件
+```python
+# 方式A: 从Google Drive
+from google.colab import drive
+drive.mount('/content/drive')
+!cp -r /content/drive/MyDrive/adaptive_RAG /content/
+%cd /content/adaptive_RAG
+
+# 方式B: 从GitHub
+!git clone YOUR_REPO_URL
+%cd adaptive_RAG
+```
+
+### 步骤3: 安装依赖
+```python
+!pip install -q -r requirements.txt
+!pip install -q -r requirements_graphrag.txt
+```
+
+### 步骤4: 配置API密钥
+```python
+import os
+from getpass import getpass
+os.environ['TAVILY_API_KEY'] = getpass('TAVILY_API_KEY: ')
+```
+
+### 步骤5: 运行GraphRAG
+```python
+!python main_graphrag.py
+```
+
+### 步骤6: 下载结果
+```python
+from google.colab import files
+files.download('data/knowledge_graph.json')
+```
+
+---
+
+## 💡 优化技巧
+
+### 1. 批处理大小
+```python
+# config.py
+GRAPHRAG_BATCH_SIZE = 20  # GPU环境可增大
+```
+
+### 2. 嵌入模型选择
+```python
+# GPU环境使用更大模型
+EMBEDDING_MODEL = "sentence-transformers/all-mpnet-base-v2"
+```
+
+### 3. 混合精度训练
+```python
+import torch
+torch.set_float32_matmul_precision('medium')
+```
+
+### 4. 数据持久化
+```python
+# 定期保存到Drive
+import shutil
+shutil.copy(
+    'data/knowledge_graph.json',
+    '/content/drive/MyDrive/backup.json'
+)
+```
+
+---
+
+## ⚠️ 注意事项
+
+### Colab免费版限制
+- ⏰ 连续使用: 最多12小时
+- 🔄 GPU配额: 每周有限
+- ⏸️ 闲置超时: 90分钟
+
+### 建议
+- 💾 定期保存进度
+- ⬇️ 及时下载结果
+- 🔄 使用后台任务保持活跃
+
+---
+
+## 📚 文件使用优先级
+
+### 新手用户
+1. 📖 先阅读 `COLAB_GPU_GUIDE.md`
+2. 🚀 运行 `colab_gpu_demo.ipynb`
+3. ✅ 验证性能后部署完整项目
+
+### 高级用户
+1. ⚡ 直接运行 `colab_quick_test.py`
+2. 📊 查看性能报告
+3. 🔧 根据需求调整配置
+
+### 开发者
+1. 🔍 研究 `colab_gpu_test.py` 源码
+2. 🛠️ 根据需求定制功能
+3. 🔄 集成到自动化流程
+
+---
+
+## 🎯 关键性能指标
+
+### 必须达到的基准
+- ✅ GPU检测: CUDA可用
+- ✅ 矩阵加速: >10x
+- ✅ 嵌入加速: >5x
+- ✅ 显存使用: <80%
+
+### 如果低于基准
+1. 检查GPU类型 (应该是T4或A100)
+2. 重启运行时
+3. 检查依赖版本
+
+---
+
+## 📞 获取帮助
+
+### 常见问题
+- 查看 `COLAB_GPU_GUIDE.md` 的FAQ部分
+
+### 性能问题
+- 运行 `colab_quick_test.py` 获取诊断报告
+
+### 技术支持
+- 提供测试报告输出
+- 说明具体错误信息
+
+---
+
+## ✅ 总结
+
+| 文件 | 何时使用 |
+|------|---------|
+| `colab_gpu_demo.ipynb` | 首次使用、学习、演示 |
+| `colab_quick_test.py` | 快速验证、CI/CD、批量测试 |
+| `colab_gpu_test.py` | 深度定制、集成开发 |
+| `COLAB_GPU_GUIDE.md` | 参考文档、问题排查 |
+
+**推荐流程**: 
+1. 阅读 `COLAB_GPU_GUIDE.md` (5分钟)
+2. 运行 `colab_quick_test.py` (5分钟)
+3. 如果性能符合预期，部署完整GraphRAG项目
+
+**预期结果**: 
+- GPU可用 ✅
+- 3-6倍整体加速 ✅
+- 节省10+分钟时间 ✅
+
+---
+
+🚀 **立即开始**: 上传任一文件到 [Google Colab](https://colab.research.google.com/) 并启用GPU!

COLAB_GPU_GUIDE.md

@@ -0,0 +1,271 @@
+# 🚀 Google Colab GPU 测试指南
+
+## 📋 概述
+
+我为您创建了两个文件用于在Google Colab上测试GPU性能：
+
+1. **`colab_gpu_demo.ipynb`** - Jupyter Notebook版本（推荐）
+2. **`colab_gpu_test.py`** - Python脚本版本
+
+## 🎯 使用方法
+
+### 方法1: 使用Notebook（推荐）
+
+#### 步骤1: 上传到Colab
+
+1. 打开 [Google Colab](https://colab.research.google.com/)
+2. 点击 `文件` → `上传笔记本`
+3. 选择 `colab_gpu_demo.ipynb`
+
+#### 步骤2: 启用GPU
+
+1. 点击顶部菜单 `运行时` → `更改运行时类型`
+2. 硬件加速器选择 `GPU`
+3. GPU类型选择 `T4`（免费版）或 `A100`（Colab Pro）
+4. 点击 `保存`
+
+#### 步骤3: 运行测试
+
+1. 点击 `运行时` → `全部运行`
+2. 或者逐个单元格运行（Shift + Enter）
+
+### 方法2: 使用Python脚本
+
+#### 步骤1: 上传文件
+
+1. 在Colab中创建新笔记本
+2. 点击左侧文件夹图标
+3. 上传 `colab_gpu_test.py`
+
+#### 步骤2: 运行脚本
+
+```python
+# 在Colab单元格中运行
+!python colab_gpu_test.py
+```
+
+## 📊 测试内容
+
+### 1. GPU环境检测 ✅
+- CUDA可用性检查
+- GPU型号和显存信息
+- nvidia-smi输出
+
+### 2. 矩阵运算性能测试 ⚡
+- CPU vs GPU 5000x5000矩阵乘法
+- 预期加速比: **10-50x**
+
+### 3. 文本嵌入性能测试 📝
+- 使用sentence-transformers
+- 1000个文本的嵌入生成
+- CPU vs GPU对比
+- 预期加速比: **5-10x**
+
+### 4. GraphRAG组件测试 🔍
+- 简化版知识图谱构建
+- 实体和关系管理
+- GPU加速的向量检索
+
+### 5. 显存监控 💾
+- 实时显存使用情况
+- 内存分配统计
+
+## 📈 预期结果
+
+### Google Colab 免费版 (T4 GPU)
+
+| 测试项目 | CPU时间 | GPU时间 | 加速比 |
+|---------|---------|---------|--------|
+| 矩阵运算 (5000x5000) | ~8-10秒 | ~0.3-0.5秒 | 20-30x |
+| 文本嵌入 (1000文本) | ~30-40秒 | ~5-8秒 | 5-7x |
+| GraphRAG索引 (100文档) | ~15分钟 | ~3-5分钟 | 3-5x |
+
+### Google Colab Pro (A100 GPU)
+
+| 测试项目 | CPU时间 | GPU时间 | 加速比 |
+|---------|---------|---------|--------|
+| 矩阵运算 | ~8秒 | ~0.2秒 | 40x |
+| 文本嵌入 | ~35秒 | ~3秒 | 10-12x |
+| GraphRAG索引 | ~15分钟 | ~2-3分钟 | 5-7x |
+
+## 🔧 运行完整GraphRAG项目
+
+如果GPU测试成功，可以在Colab上运行完整的GraphRAG项目：
+
+### 步骤1: 上传项目文件
+
+在Colab中创建新的单元格：
+
+```python
+# 方式1: 从Google Drive加载
+from google.colab import drive
+drive.mount('/content/drive')
+
+# 复制项目文件
+!cp -r /content/drive/MyDrive/adaptive_RAG /content/
+%cd /content/adaptive_RAG
+```
+
+或者：
+
+```python
+# 方式2: 从GitHub克隆
+!git clone YOUR_GITHUB_REPO_URL
+%cd adaptive_RAG
+```
+
+### 步骤2: 安装依赖
+
+```python
+# 安装基础依赖
+!pip install -q -r requirements.txt
+
+# 安装GraphRAG依赖
+!pip install -q -r requirements_graphrag.txt
+```
+
+### 步骤3: 配置API密钥
+
+```python
+import os
+from getpass import getpass
+
+# 安全输入API密钥
+os.environ['TAVILY_API_KEY'] = getpass('输入 TAVILY_API_KEY: ')
+
+# 验证
+print("✅ API密钥已设置")
+```
+
+### 步骤4: 运行GraphRAG
+
+```python
+# 运行主程序
+!python main_graphrag.py
+```
+
+### 步骤5: 下载结果
+
+```python
+# 下载构建好的知识图谱
+from google.colab import files
+
+# 下载图谱文件
+files.download('data/knowledge_graph.json')
+
+print("✅ 图谱已下载到本地")
+```
+
+## 💡 优化建议
+
+### 1. 批处理大小优化
+
+在 `config.py` 中调整：
+
+```python
+# GPU优化配置
+GRAPHRAG_BATCH_SIZE = 20  # GPU可以处理更大批次
+```
+
+### 2. 使用GPU优化的模型
+
+```python
+# 使用更大的嵌入模型（GPU环境）
+EMBEDDING_MODEL = "sentence-transformers/all-mpnet-base-v2"
+```
+
+### 3. 启用混合精度
+
+```python
+# 在entity_extractor.py中
+import torch
+torch.set_float32_matmul_precision('medium')  # 提升性能
+```
+
+## ⚠️ 注意事项
+
+### Colab资源限制
+
+1. **免费版限制**:
+   - 连续使用时间: 最多12小时
+   - GPU使用配额: 每周有限
+   - 闲置超时: 90分钟自动断开
+
+2. **建议**:
+   - 定期保存进度到Google Drive
+   - 使用`files.download()`下载重要结果
+   - 避免长时间空闲
+
+### 数据持久化
+
+```python
+# 定期保存到Google Drive
+from google.colab import drive
+drive.mount('/content/drive')
+
+# 保存图谱
+import shutil
+shutil.copy(
+    'data/knowledge_graph.json',
+    '/content/drive/MyDrive/graphrag_backup.json'
+)
+```
+
+## 🐛 常见问题
+
+### Q1: GPU连接失败
+
+**A**: 检查运行时类型
+```python
+import torch
+print(f"CUDA可用: {torch.cuda.is_available()}")
+# 如果False，重新设置运行时类型
+```
+
+### Q2: 内存不足
+
+**A**: 减小批处理大小
+```python
+GRAPHRAG_BATCH_SIZE = 5  # 降低批次
+```
+
+### Q3: 会话超时
+
+**A**: 使用Colab Pro或定期运行代码保持活跃
+```python
+# 在后台定期执行
+import time
+while True:
+    print("Keep alive...")
+    time.sleep(300)  # 每5分钟执行一次
+```
+
+## 📚 参考资源
+
+- [Google Colab官方文档](https://colab.research.google.com/notebooks/intro.ipynb)
+- [GPU加速指南](https://colab.research.google.com/notebooks/gpu.ipynb)
+- [Colab Pro定价](https://colab.research.google.com/signup)
+
+## 🎓 下一步学习
+
+1. **理解GPU加速原理**: 查看测试代码中的性能对比
+2. **优化GraphRAG参数**: 根据GPU性能调整配置
+3. **扩展到生产环境**: 考虑使用AWS/GCP的GPU实例
+
+---
+
+## ✅ 总结
+
+| 优势 | 说明 |
+|------|------|
+| 🆓 免费GPU | T4 GPU免费使用 |
+| ⚡ 高性能 | 3-10倍加速 |
+| 🔄 零配置 | 无需本地安装 |
+| 💾 自动保存 | 集成Google Drive |
+| 🌐 随时访问 | 仅需浏览器 |
+
+**推荐**: 在本地CPU环境速度慢时，使用Colab GPU可以大幅提升GraphRAG索引构建速度！
+
+---
+
+**立即开始**: 上传 `colab_gpu_demo.ipynb` 到 [Google Colab](https://colab.research.google.com/) 并启用GPU! 🚀

COLAB_OLLAMA_GUIDE.md

@@ -0,0 +1,421 @@
+# GraphRAG Colab 完整运行指南
+
+## 🎯 在Colab中运行Ollama的3种方法
+
+### 方法1: 后台运行Ollama（推荐）⭐⭐⭐⭐⭐
+
+在Colab中，您可以在单个单元格中后台启动Ollama，然后在另一个单元格运行GraphRAG。
+
+#### 步骤1: 安装Ollama
+
+```bash
+# 单元格1: 安装Ollama
+!curl -fsSL https://ollama.com/install.sh | sh
+```
+
+#### 步骤2: 后台启动Ollama服务
+
+```python
+# 单元格2: 后台启动Ollama
+import subprocess
+import time
+import os
+
+# 启动Ollama服务（后台）
+ollama_process = subprocess.Popen(
+    ["ollama", "serve"],
+    stdout=subprocess.PIPE,
+    stderr=subprocess.PIPE,
+    preexec_fn=os.setpgrp
+)
+
+print("⏳ 等待Ollama服务启动...")
+time.sleep(5)
+
+# 验证服务是否启动
+!curl -s http://localhost:11434/api/tags | head -5
+
+print(f"✅ Ollama服务已启动 (PID: {ollama_process.pid})")
+```
+
+#### 步骤3: 下载Mistral模型
+
+```bash
+# 单元格3: 下载模型
+!ollama pull mistral
+```
+
+#### 步骤4: 安装Python依赖
+
+```bash
+# 单元格4: 安装依赖
+!pip install -q langchain langchain-community langchain-core langgraph
+!pip install -q chromadb sentence-transformers tiktoken
+!pip install -q tavily-python python-dotenv networkx python-louvain
+```
+
+#### 步骤5: 配置API密钥
+
+```python
+# 单元格5: 配置环境
+import os
+from getpass import getpass
+
+os.environ['TAVILY_API_KEY'] = getpass('输入TAVILY_API_KEY: ')
+print("✅ API密钥已设置")
+```
+
+#### 步骤6: 运行GraphRAG
+
+```python
+# 单元格6: 运行GraphRAG
+!python main_graphrag.py
+```
+
+#### 步骤7: 下载结果（可选）
+
+```python
+# 单元格7: 下载生成的图谱
+from google.colab import files
+files.download('data/knowledge_graph.json')
+```
+
+---
+
+### 方法2: 使用tmux（高级）⭐⭐⭐⭐
+
+```bash
+# 单元格1: 安装tmux
+!apt-get install -y tmux
+
+# 单元格2: 在tmux会话中启动Ollama
+!tmux new-session -d -s ollama 'ollama serve'
+
+# 单元格3: 检查会话
+!tmux ls
+
+# 单元格4: 下载模型
+!ollama pull mistral
+
+# 单元格5: 运行GraphRAG
+!python main_graphrag.py
+
+# 单元格6: 停止tmux会话（清理）
+!tmux kill-session -t ollama
+```
+
+---
+
+### 方法3: 使用nohup（简单）⭐⭐⭐
+
+```bash
+# 单元格1: 后台启动Ollama
+!nohup ollama serve > /tmp/ollama.log 2>&1 &
+
+# 单元格2: 等待启动
+import time
+time.sleep(5)
+
+# 单元格3: 检查日志
+!tail -20 /tmp/ollama.log
+
+# 单元格4: 下载模型
+!ollama pull mistral
+
+# 单元格5: 运行GraphRAG
+!python main_graphrag.py
+
+# 单元格6: 停止Ollama（清理）
+!pkill -f 'ollama serve'
+```
+
+---
+
+## 🚀 一键运行脚本（最简单）⭐⭐⭐⭐⭐
+
+我已经为您创建了一个自动化脚本 `colab_setup_and_run.py`，它会：
+1. ✅ 自动安装Ollama
+2. ✅ 后台启动服务
+3. ✅ 下载Mistral模型
+4. ✅ 安装Python依赖
+5. ✅ 配置环境变量
+6. ✅ 运行GraphRAG
+
+### 使用方法:
+
+```bash
+# 方法A: 直接运行脚本
+!python colab_setup_and_run.py
+
+# 方法B: 或者在Python中
+import subprocess
+subprocess.run(["python", "colab_setup_and_run.py"])
+```
+
+---
+
+## 📊 完整的Colab Notebook示例
+
+创建一个新的Colab笔记本，按顺序运行以下单元格：
+
+### 单元格1: 环境准备
+
+```python
+# 检测GPU
+import torch
+print(f"GPU可用: {torch.cuda.is_available()}")
+if torch.cuda.is_available():
+    print(f"GPU型号: {torch.cuda.get_device_name(0)}")
+```
+
+### 单元格2: 安装Ollama
+
+```bash
+%%bash
+curl -fsSL https://ollama.com/install.sh | sh
+echo "✅ Ollama安装完成"
+```
+
+### 单元格3: 后台启动Ollama
+
+```python
+import subprocess
+import time
+import os
+
+print("🔄 启动Ollama服务...")
+
+# 后台启动
+process = subprocess.Popen(
+    ["ollama", "serve"],
+    stdout=subprocess.PIPE,
+    stderr=subprocess.PIPE,
+    preexec_fn=os.setpgrp
+)
+
+# 等待启动
+time.sleep(5)
+
+# 验证
+import requests
+try:
+    response = requests.get("http://localhost:11434/api/tags", timeout=3)
+    if response.status_code == 200:
+        print(f"✅ Ollama服务运行正常 (PID: {process.pid})")
+    else:
+        print("⚠️  服务响应异常")
+except:
+    print("⚠️  无法连接服务，但进程已启动")
+
+# 保存进程ID（重要！）
+ollama_pid = process.pid
+print(f"📝 保存的PID: {ollama_pid}")
+```
+
+### 单元格4: 下载模型
+
+```bash
+%%bash
+echo "📥 下载Mistral模型..."
+ollama pull mistral
+echo "✅ 模型下载完成"
+ollama list
+```
+
+### 单元格5: 上传项目文件
+
+```python
+# 方式A: 从Google Drive
+from google.colab import drive
+drive.mount('/content/drive')
+
+# 复制项目文件
+!cp -r /content/drive/MyDrive/adaptive_RAG /content/
+%cd /content/adaptive_RAG
+
+# 方式B: 手动上传
+# from google.colab import files
+# uploaded = files.upload()
+```
+
+### 单元格6: 安装依赖
+
+```bash
+%%bash
+pip install -q -r requirements.txt
+pip install -q -r requirements_graphrag.txt
+echo "✅ 依赖安装完成"
+```
+
+### 单元格7: 配置环境
+
+```python
+import os
+from getpass import getpass
+
+# 设置API密钥
+if not os.path.exists('.env'):
+    api_key = getpass('输入TAVILY_API_KEY: ')
+    with open('.env', 'w') as f:
+        f.write(f'TAVILY_API_KEY={api_key}\n')
+    print("✅ .env文件已创建")
+else:
+    print("✅ 使用现有.env文件")
+```
+
+### 单元格8: 运行GraphRAG
+
+```python
+# 方式A: 直接运行
+!python main_graphrag.py
+
+# 方式B: 在Python中运行（可以捕获输出）
+import subprocess
+
+result = subprocess.run(
+    ["python", "main_graphrag.py"],
+    capture_output=True,
+    text=True
+)
+
+print(result.stdout)
+if result.returncode != 0:
+    print("错误信息:")
+    print(result.stderr)
+```
+
+### 单元格9: 下载结果
+
+```python
+# 下载生成的知识图谱
+from google.colab import files
+
+if os.path.exists('data/knowledge_graph.json'):
+    files.download('data/knowledge_graph.json')
+    print("✅ 文件已下载")
+else:
+    print("❌ 未找到图谱文件")
+
+# 保存到Google Drive
+import shutil
+shutil.copy(
+    'data/knowledge_graph.json',
+    '/content/drive/MyDrive/graphrag_backup.json'
+)
+print("✅ 已备份到Google Drive")
+```
+
+### 单元格10: 清理（可选）
+
+```python
+# 停止Ollama服务
+import os
+import signal
+
+try:
+    os.kill(ollama_pid, signal.SIGTERM)
+    print(f"✅ Ollama服务已停止 (PID: {ollama_pid})")
+except:
+    print("⚠️  停止服务失败，手动停止:")
+    !pkill -f 'ollama serve'
+```
+
+---
+
+## ⚠️ 常见问题
+
+### Q1: Ollama服务启动后立即退出
+
+**A**: 使用 `subprocess.Popen` 而不是 `subprocess.run`:
+
+```python
+# ❌ 错误方式
+!ollama serve &  # 会立即退出
+
+# ✅ 正确方式
+import subprocess
+process = subprocess.Popen(["ollama", "serve"])
+```
+
+### Q2: 连接被拒绝 (Connection refused)
+
+**A**: 等待服务完全启动:
+
+```python
+import time
+time.sleep(10)  # 增加等待时间
+```
+
+### Q3: 进程管理困难
+
+**A**: 使用PID文件:
+
+```python
+# 保存PID
+with open('/tmp/ollama.pid', 'w') as f:
+    f.write(str(process.pid))
+
+# 后续停止
+with open('/tmp/ollama.pid', 'r') as f:
+    pid = int(f.read())
+os.kill(pid, signal.SIGTERM)
+```
+
+### Q4: 会话超时导致服务停止
+
+**A**: 定期执行代码保持活跃:
+
+```python
+import time
+while True:
+    print("Keep alive...")
+    time.sleep(300)  # 每5分钟
+```
+
+---
+
+## 📚 推荐的完整流程
+
+1. ✅ **运行自动化脚本** - `!python colab_setup_and_run.py`
+2. ✅ **或按照Notebook示例** - 逐步执行每个单元格
+3. ✅ **定期保存结果** - 到Google Drive
+
+---
+
+## 💡 最佳实践
+
+1. **始终保存Ollama的PID**: 方便后续管理
+2. **使用try-finally**: 确保清理后台进程
+3. **定期备份**: 保存中间结果到Drive
+4. **监控显存**: 避免OOM错误
+
+```python
+# 最佳实践示例
+import subprocess
+import atexit
+import signal
+
+# 启动Ollama
+ollama_process = subprocess.Popen(["ollama", "serve"])
+
+# 注册清理函数
+def cleanup():
+    try:
+        ollama_process.terminate()
+        print("✅ Ollama已停止")
+    except:
+        pass
+
+atexit.register(cleanup)
+
+# 运行您的代码
+try:
+    # ... 您的GraphRAG代码 ...
+    pass
+finally:
+    cleanup()
+```
+
+---
+
+**推荐**: 直接使用 `colab_setup_and_run.py` 脚本，它已经处理了所有这些细节！🚀

DEPLOYMENT_GUIDE.md

@@ -0,0 +1,440 @@
+# Linux GPU部署指南 (RTX 4090)
+
+## 🚀 自适应RAG系统在Linux RTX 4090环境部署
+
+本指南将详细介绍如何在配备NVIDIA RTX 4090 GPU的Linux服务器上部署自适应RAG系统。
+
+## 📋 环境要求
+
+### 硬件要求
+- NVIDIA RTX 4090 GPU
+- 至少16GB内存（推荐32GB）
+- 50GB+可用磁盘空间
+- Ubuntu 20.04+ / CentOS 8+ / RHEL 8+
+
+### 软件要求
+- Linux操作系统（推荐Ubuntu 22.04 LTS）
+- NVIDIA驱动程序（推荐535+）
+- CUDA 12.0+
+- Docker（可选但推荐）
+- Python 3.8-3.11
+
+## 🔧 步骤1：系统准备
+
+### 1.1 更新系统
+```bash
+sudo apt update && sudo apt upgrade -y
+sudo apt install -y curl wget git build-essential python3-pip python3-venv
+```
+
+### 1.2 安装NVIDIA驱动和CUDA
+```bash
+# 检查GPU
+lspci | grep -i nvidia
+
+# 添加NVIDIA软件源
+wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/cuda-keyring_1.0-1_all.deb
+sudo dpkg -i cuda-keyring_1.0-1_all.deb
+sudo apt-get update
+
+# 安装NVIDIA驱动和CUDA
+sudo apt-get install -y nvidia-driver-535 cuda-12-2
+
+# 重启系统
+sudo reboot
+```
+
+### 1.3 验证GPU安装
+```bash
+# 重启后验证
+nvidia-smi
+nvcc --version
+```
+
+## 🐳 步骤2：Docker环境配置（推荐）
+
+### 2.1 安装Docker
+```bash
+# 安装Docker
+curl -fsSL https://get.docker.com -o get-docker.sh
+sudo sh get-docker.sh
+sudo usermod -aG docker $USER
+```
+
+### 2.2 安装NVIDIA Container Toolkit
+```bash
+# 添加NVIDIA Docker源
+distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
+curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
+curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list
+
+# 安装nvidia-container-toolkit
+sudo apt-get update
+sudo apt-get install -y nvidia-container-toolkit
+sudo systemctl restart docker
+```
+
+### 2.3 创建Dockerfile
+```dockerfile
+# 创建 Dockerfile
+cat > Dockerfile << 'EOF'
+FROM nvidia/cuda:12.2-devel-ubuntu22.04
+
+# 设置非交互模式
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
+
+# 更新系统并安装Python
+RUN apt-get update && apt-get install -y \
+    python3 \
+    python3-pip \
+    python3-venv \
+    git \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# 创建工作目录
+WORKDIR /app
+
+# 复制项目文件
+COPY requirements.txt .
+COPY *.py .
+COPY *.md .
+
+# 安装Python依赖
+RUN pip3 install --no-cache-dir -r requirements.txt
+
+# 暴露端口（如果需要Web界面）
+EXPOSE 8000
+
+# 启动命令
+CMD ["python3", "main.py"]
+EOF
+```
+
+## 🐍 步骤3：Python环境配置（直接部署）
+
+### 3.1 创建Python虚拟环境
+```bash
+# 克隆项目
+git clone <your-repo-url> adaptive_rag
+cd adaptive_rag
+
+# 创建虚拟环境
+python3 -m venv rag_env
+source rag_env/bin/activate
+
+# 升级pip
+pip install --upgrade pip
+```
+
+### 3.2 修改requirements.txt以支持GPU
+需要更新requirements.txt以优化GPU使用：
+
+```bash
+# 创建GPU优化的requirements文件
+cat > requirements_gpu.txt << 'EOF'
+# 核心框架
+langchain>=0.1.0
+langgraph>=0.0.40
+langchain-community>=0.0.20
+langchain-core>=0.1.0
+
+# LLM集成
+langchain-ollama>=0.1.0
+
+# 向量数据库和嵌入（GPU优化版本）
+chromadb>=0.4.0
+sentence-transformers>=2.2.0
+torch>=2.0.0+cu118 --index-url https://download.pytorch.org/whl/cu118
+torchvision>=0.15.0+cu118 --index-url https://download.pytorch.org/whl/cu118
+transformers>=4.30.0
+accelerate>=0.20.0
+
+# 文档处理
+tiktoken>=0.5.0
+beautifulsoup4>=4.12.0
+requests>=2.31.0
+
+# 网络搜索
+tavily-python>=0.3.0
+
+# 数据处理
+numpy>=1.24.0,<2.0
+pandas>=2.0.0
+
+# 工具库
+python-dotenv>=1.0.0
+pydantic>=2.0.0
+typing-extensions>=4.0.0
+
+# GPU加速库
+cupy-cuda12x>=12.0.0
+faiss-gpu>=1.7.4
+EOF
+```
+
+### 3.3 安装依赖
+```bash
+# 安装GPU优化依赖
+pip install -r requirements_gpu.txt
+```
+
+## 🛠️ 步骤4：修改配置以优化GPU使用
+
+### 4.1 更新document_processor.py以使用GPU
+需要修改嵌入模型配置：
+
+```python
+# 在document_processor.py中修改
+self.embeddings = HuggingFaceEmbeddings(
+    model_name="sentence-transformers/all-MiniLM-L6-v2",
+    model_kwargs={'device': 'cuda'},  # 使用GPU
+    encode_kwargs={'normalize_embeddings': True}
+)
+```
+
+### 4.2 创建GPU优化配置
+```python
+# 创建 gpu_config.py
+cat > gpu_config.py << 'EOF'
+import torch
+import os
+
+# GPU配置
+if torch.cuda.is_available():
+    DEVICE = "cuda"
+    GPU_COUNT = torch.cuda.device_count()
+    GPU_NAME = torch.cuda.get_device_name(0)
+    print(f"发现 {GPU_COUNT} 个GPU: {GPU_NAME}")
+    
+    # 设置CUDA优化
+    torch.backends.cudnn.benchmark = True
+    torch.backends.cudnn.deterministic = False
+    
+    # 设置GPU内存管理
+    torch.cuda.empty_cache()
+else:
+    DEVICE = "cpu"
+    print("未发现GPU，使用CPU模式")
+
+# 优化设置
+EMBEDDING_BATCH_SIZE = 32 if DEVICE == "cuda" else 8
+MAX_WORKERS = 4 if DEVICE == "cuda" else 2
+EOF
+```
+
+## 🤖 步骤5：安装和配置Ollama
+
+### 5.1 安装Ollama
+```bash
+# 下载并安装Ollama
+curl -fsSL https://ollama.ai/install.sh | sh
+
+# 或者使用Docker
+# docker run -d --gpus=all -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama
+```
+
+### 5.2 下载模型
+```bash
+# 下载Mistral模型
+ollama pull mistral
+
+# 或者下载更大的模型（如果GPU内存足够）
+ollama pull llama2:13b
+ollama pull codellama:34b
+```
+
+### 5.3 启动Ollama服务
+```bash
+# 启动Ollama服务
+ollama serve &
+
+# 验证服务
+curl http://localhost:11434/api/version
+```
+
+## 🔐 步骤6：环境变量配置
+
+### 6.1 创建.env文件
+```bash
+cat > .env << 'EOF'
+# API密钥
+TAVILY_API_KEY=your_tavily_api_key_here
+
+# GPU配置
+CUDA_VISIBLE_DEVICES=0
+TORCH_CUDA_ARCH_LIST="8.9"  # RTX 4090架构
+
+# 模型配置
+HF_HOME=/app/models
+TRANSFORMERS_CACHE=/app/models
+
+# 性能优化
+OMP_NUM_THREADS=8
+MKL_NUM_THREADS=8
+EOF
+```
+
+## 🚀 步骤7：部署和启动
+
+### 7.1 使用Docker部署
+```bash
+# 构建镜像
+docker build -t adaptive-rag:gpu .
+
+# 运行容器
+docker run -d \
+  --gpus all \
+  --name adaptive-rag \
+  --env-file .env \
+  -p 8000:8000 \
+  -v $(pwd)/data:/app/data \
+  adaptive-rag:gpu
+```
+
+### 7.2 直接Python部署
+```bash
+# 激活虚拟环境
+source rag_env/bin/activate
+
+# 启动系统
+python main.py
+```
+
+## 📊 步骤8：性能监控
+
+### 8.1 创建监控脚本
+```bash
+cat > monitor_gpu.py << 'EOF'
+import psutil
+import GPUtil
+import time
+
+def monitor_system():
+    while True:
+        # GPU监控
+        gpus = GPUtil.getGPUs()
+        for gpu in gpus:
+            print(f"GPU {gpu.id}: {gpu.load*100}% | 内存: {gpu.memoryUsed}MB/{gpu.memoryTotal}MB")
+        
+        # CPU和内存监控
+        print(f"CPU: {psutil.cpu_percent()}% | 内存: {psutil.virtual_memory().percent}%")
+        print("-" * 50)
+        time.sleep(5)
+
+if __name__ == "__main__":
+    monitor_system()
+EOF
+
+pip install gputil
+python monitor_gpu.py
+```
+
+## 🔧 步骤9：性能优化配置
+
+### 9.1 创建优化启动脚本
+```bash
+cat > start_optimized.sh << 'EOF'
+#!/bin/bash
+
+# 设置GPU优化环境变量
+export CUDA_VISIBLE_DEVICES=0
+export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:512
+export TOKENIZERS_PARALLELISM=false
+
+# 启动系统
+source rag_env/bin/activate
+python main.py
+EOF
+
+chmod +x start_optimized.sh
+```
+
+### 9.2 创建系统服务
+```bash
+# 创建systemd服务
+sudo tee /etc/systemd/system/adaptive-rag.service > /dev/null << 'EOF'
+[Unit]
+Description=Adaptive RAG System
+After=network.target
+
+[Service]
+Type=simple
+User=your_username
+WorkingDirectory=/path/to/adaptive_rag
+Environment=PATH=/path/to/adaptive_rag/rag_env/bin
+ExecStart=/path/to/adaptive_rag/rag_env/bin/python main.py
+Restart=always
+RestartSec=10
+
+[Install]
+WantedBy=multi-user.target
+EOF
+
+# 启用服务
+sudo systemctl daemon-reload
+sudo systemctl enable adaptive-rag
+sudo systemctl start adaptive-rag
+```
+
+## 🐛 步骤10：故障排除
+
+### 10.1 常见问题
+
+1. **CUDA内存不足**
+```bash
+# 减少批处理大小
+export EMBEDDING_BATCH_SIZE=16
+# 或者启用梯度检查点
+export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:256
+```
+
+2. **Ollama连接问题**
+```bash
+# 检查Ollama状态
+sudo systemctl status ollama
+# 重启Ollama
+sudo systemctl restart ollama
+```
+
+3. **权限问题**
+```bash
+# 添加用户到docker组
+sudo usermod -aG docker $USER
+# 重新登录
+```
+
+### 10.2 性能调优
+
+```bash
+# GPU性能模式
+sudo nvidia-smi -pm 1
+sudo nvidia-smi -ac 9251,2100
+
+# 系统优化
+echo 'vm.swappiness=10' | sudo tee -a /etc/sysctl.conf
+sudo sysctl -p
+```
+
+## 📈 预期性能
+
+在RTX 4090环境下的预期性能：
+- **文档嵌入**: ~1000 documents/second
+- **查询响应**: ~2-5 seconds per query
+- **GPU利用率**: 60-80%
+- **内存使用**: 8-12GB GPU memory
+
+## 🎯 验证部署
+
+```bash
+# 测试GPU可用性
+python -c "import torch; print(f'CUDA可用: {torch.cuda.is_available()}'); print(f'GPU数量: {torch.cuda.device_count()}')"
+
+# 测试系统
+curl -X POST http://localhost:8000/query \
+  -H "Content-Type: application/json" \
+  -d '{"question": "什么是LLM智能体？"}'
+```
+
+这个部署指南提供了完整的Linux GPU环境配置，确保您的自适应RAG系统能够充分利用RTX 4090的计算能力。

Dockerfile.gpu

@@ -0,0 +1,58 @@
+# GPU优化Dockerfile - 针对RTX 4090
+FROM nvidia/cuda:12.2-devel-ubuntu22.04
+
+# 设置非交互模式和环境变量
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
+ENV CUDA_VISIBLE_DEVICES=0
+ENV PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:512
+
+# 更新系统并安装必要软件
+RUN apt-get update && apt-get install -y \
+    python3 \
+    python3-pip \
+    python3-venv \
+    git \
+    curl \
+    wget \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# 创建应用目录
+WORKDIR /app
+
+# 创建必要目录
+RUN mkdir -p /app/data /app/models /app/logs
+
+# 复制依赖文件
+COPY requirements_gpu.txt .
+
+# 升级pip并安装Python依赖
+RUN pip3 install --no-cache-dir --upgrade pip && \
+    pip3 install --no-cache-dir -r requirements_gpu.txt
+
+# 复制应用文件
+COPY *.py .
+COPY *.md .
+COPY .env.example .
+
+# 设置Python路径
+ENV PYTHONPATH=/app
+
+# 创建启动脚本
+RUN echo '#!/bin/bash\n\
+export CUDA_VISIBLE_DEVICES=0\n\
+export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:512\n\
+export TOKENIZERS_PARALLELISM=false\n\
+python3 -c "import torch; print(f'"'"'CUDA可用: {torch.cuda.is_available()}'"'"'); print(f'"'"'GPU数量: {torch.cuda.device_count()}'"'"')"\n\
+python3 main.py' > /app/start.sh && chmod +x /app/start.sh
+
+# 暴露端口
+EXPOSE 8000 8001
+
+# 健康检查
+HEALTHCHECK --interval=30s --timeout=30s --start-period=60s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# 启动命令
+CMD ["/app/start.sh"]

GRAPHRAG_GUIDE.md

@@ -0,0 +1,401 @@
+# GraphRAG 集成指南
+
+## 📋 概述
+
+本项目已集成**Microsoft GraphRAG**架构，通过知识图谱增强传统向量检索，提供更精准的信息提取和推理能力。
+
+## 🏗️ GraphRAG 架构
+
+### 核心组件
+
+```
+文档集合
+    ↓
+┌─────────────────────────────────────┐
+│  实体和关系提取 (Entity Extraction)   │
+│  - 使用LLM识别实体                    │
+│  - 提取实体间关系                     │
+└─────────────────────────────────────┘
+    ↓
+┌─────────────────────────────────────┐
+│  知识图谱构建 (Graph Construction)    │
+│  - 实体去重                          │
+│  - 构建图结构                        │
+└─────────────────────────────────────┘
+    ↓
+┌─────────────────────────────────────┐
+│  社区检测 (Community Detection)       │
+│  - Louvain算法                       │
+│  - 层次化聚类                        │
+└─────────────────────────────────────┘
+    ↓
+┌─────────────────────────────────────┐
+│  社区摘要生成 (Community Summaries)   │
+│  - LLM生成摘要                       │
+│  - 多层次索引                        │
+└─────────────────────────────────────┘
+    ↓
+    查询阶段
+    ↓
+┌──────────────┬──────────────┐
+│  本地查询     │   全局查询    │
+│ (Local Query)│(Global Query)│
+│              │              │
+│ 实体邻域检索  │  社区摘要查询 │
+└──────────────┴──────────────┘
+```
+
+## 📦 新增文件说明
+
+### 1. **entity_extractor.py** - 实体提取器
+```python
+EntityExtractor
+├── extract_entities()      # 从文本提取实体
+├── extract_relations()     # 提取实体关系
+└── extract_from_document() # 完整文档处理
+
+EntityDeduplicator
+└── deduplicate_entities()  # 实体去重
+```
+
+**功能**:
+- 使用LLM识别6种实体类型 (PERSON, ORGANIZATION, CONCEPT, TECHNOLOGY, PAPER, EVENT)
+- 提取8种关系类型 (AUTHOR_OF, USES, BASED_ON, etc.)
+- 智能实体去重和合并
+
+### 2. **knowledge_graph.py** - 知识图谱核心
+```python
+KnowledgeGraph
+├── add_entity()                 # 添加节点
+├── add_relation()               # 添加边
+├── build_from_extractions()     # 构建图谱
+├── detect_communities()         # 社区检测
+├── get_community_members()      # 获取社区成员
+└── get_statistics()             # 统计信息
+
+CommunitySummarizer
+├── summarize_community()        # 单社区摘要
+└── summarize_all_communities()  # 全部社区摘要
+```
+
+**功能**:
+- 基于NetworkX的图谱管理
+- 支持3种社区检测算法 (Louvain, Greedy, Label Propagation)
+- LLM驱动的社区摘要生成
+- 图谱持久化存储
+
+### 3. **graph_indexer.py** - 索引构建器
+```python
+GraphRAGIndexer
+├── index_documents()  # 构建索引
+├── get_graph()        # 获取图谱
+└── load_index()       # 加载索引
+```
+
+**流程**:
+1. 批量实体提取
+2. 实体去重合并
+3. 构建知识图谱
+4. 社区检测
+5. 生成摘要
+
+### 4. **graph_retriever.py** - 图谱检索器
+```python
+GraphRetriever
+├── recognize_entities()  # 识别问题中的实体
+├── local_query()         # 本地查询
+├── global_query()        # 全局查询
+├── hybrid_query()        # 混合查询
+└── smart_query()         # 智能查询
+```
+
+**查询模式**:
+- **本地查询**: 针对特定实体的详细问题
+- **全局查询**: 需要整体理解的概括性问题
+- **智能查询**: 自动选择最佳策略
+
+### 5. **main_graphrag.py** - GraphRAG集成示例
+完整的使用示例和交互式界面
+
+### 6. **requirements_graphrag.txt** - 额外依赖
+GraphRAG所需的图处理库
+
+## 🚀 快速开始
+
+### 安装依赖
+
+```bash
+# 安装基础依赖
+pip install -r requirements.txt
+
+# 安装GraphRAG依赖
+pip install -r requirements_graphrag.txt
+```
+
+### 首次使用
+
+```python
+# 方式1: 使用集成示例
+python main_graphrag.py
+
+# 方式2: 在代码中集成
+from config import setup_environment
+from document_processor import initialize_document_processor
+from graph_indexer import initialize_graph_indexer
+from graph_retriever import initialize_graph_retriever
+
+# 初始化
+setup_environment()
+processor, vectorstore, retriever, doc_splits = initialize_document_processor()
+
+# 构建GraphRAG索引
+graph_indexer = initialize_graph_indexer()
+knowledge_graph = graph_indexer.index_documents(
+    documents=doc_splits,
+    save_path="./data/knowledge_graph.json"
+)
+
+# 初始化检索器
+graph_retriever = initialize_graph_retriever(knowledge_graph)
+
+# 查询
+answer = graph_retriever.smart_query("LLM Agent的核心组件是什么？")
+print(answer)
+```
+
+## 🔧 配置说明
+
+在 `config.py` 中添加了以下配置:
+
+```python
+# GraphRAG配置
+ENABLE_GRAPHRAG = True                           # 是否启用GraphRAG
+GRAPHRAG_INDEX_PATH = "./data/knowledge_graph.json"  # 图谱存储路径
+GRAPHRAG_COMMUNITY_ALGORITHM = "louvain"         # 社区检测算法
+GRAPHRAG_MAX_HOPS = 2                            # 本地查询最大跳数
+GRAPHRAG_TOP_K_COMMUNITIES = 5                   # 全局查询使用的社区数
+GRAPHRAG_BATCH_SIZE = 10                         # 实体提取批大小
+```
+
+## 📊 使用场景对比
+
+### 传统向量检索 vs GraphRAG
+
+| 场景 | 向量检索 | GraphRAG | 推荐 |
+|-----|---------|----------|------|
+| "AlphaCodium的作者是谁？" | ⚠️ 可能找到但不精确 | ✅ 直接查询实体关系 | GraphRAG本地查询 |
+| "这些文档讨论什么主题？" | ⚠️ 需要读取多个片段 | ✅ 社区摘要直接回答 | GraphRAG全局查询 |
+| "提示工程的应用场景" | ✅ 语义匹配效果好 | ✅ 可追踪关系链 | 混合查询 |
+| "最新技术发展" | ✅ 适合模糊查询 | ❌ 需要明确实体 | 向量检索 |
+
+## 🎯 查询策略选择
+
+### 本地查询 (Local Query)
+**适用**: 针对特定实体的详细问题
+
+```python
+# 示例问题
+"LLM Agent包含哪些组件？"
+"Transformer模型的作者是谁？"
+"AlphaCodium使用了什么技术？"
+
+# 代码
+answer = graph_retriever.local_query(question, max_hops=2)
+```
+
+**工作原理**:
+1. 识别问题中的实体
+2. 扩展到邻居节点（支持多跳）
+3. 收集实体信息和关系
+4. 基于子图生成答案
+
+### 全局查询 (Global Query)
+**适用**: 需要整体视角的概括性问题
+
+```python
+# 示例问题
+"这些文档的主要主题是什么？"
+"涵盖了哪些研究领域？"
+"关键的技术趋势有哪些？"
+
+# 代码
+answer = graph_retriever.global_query(question, top_k_communities=5)
+```
+
+**工作原理**:
+1. 获取社区摘要
+2. 基于摘要理解全局结构
+3. 综合多个社区的信息
+4. 生成高层次答案
+
+### 智能查询 (Smart Query)
+**适用**: 自动选择最佳策略
+
+```python
+# 自动判断使用本地还是全局查询
+answer = graph_retriever.smart_query(question)
+```
+
+**决策逻辑**:
+- 包含具体实体名称 → 本地查询
+- 包含"主要"、"总体"、"概述"等关键词 → 全局查询
+- 默认 → 本地查询
+
+### 混合查询 (Hybrid Query)
+**适用**: 需要多种视角的复杂问题
+
+```python
+result = graph_retriever.hybrid_query(question)
+# 返回: {"local": "...", "global": "..."}
+```
+
+## 📈 性能优化
+
+### 索引构建优化
+
+```python
+# 1. 批处理大小
+graph_indexer.index_documents(
+    documents=doc_splits,
+    batch_size=20  # 增大批处理提高速度
+)
+
+# 2. 增量索引（开发中）
+# 避免每次重建整个图谱
+
+# 3. 缓存已有索引
+if os.path.exists(GRAPHRAG_INDEX_PATH):
+    knowledge_graph = graph_indexer.load_index(GRAPHRAG_INDEX_PATH)
+```
+
+### 查询优化
+
+```python
+# 1. 调整跳数
+answer = graph_retriever.local_query(question, max_hops=1)  # 减少跳数提速
+
+# 2. 限制社区数量
+answer = graph_retriever.global_query(question, top_k_communities=3)  # 减少社区数
+
+# 3. 实体识别缓存（开发中）
+```
+
+## 🔍 调试和可视化
+
+### 查看图谱统计
+
+```python
+stats = knowledge_graph.get_statistics()
+print(f"节点数: {stats['num_nodes']}")
+print(f"边数: {stats['num_edges']}")
+print(f"社区数: {stats['num_communities']}")
+```
+
+### 导出图谱
+
+```python
+# 保存为JSON
+knowledge_graph.save_to_file("my_graph.json")
+
+# 加载图谱
+knowledge_graph.load_from_file("my_graph.json")
+```
+
+### 可视化（可选）
+
+```python
+# 需要额外安装: pip install pyvis
+from pyvis.network import Network
+
+def visualize_graph(kg, output="graph.html"):
+    net = Network(height="750px", width="100%", bgcolor="#222222", font_color="white")
+    
+    for node, data in kg.graph.nodes(data=True):
+        net.add_node(node, label=node, title=data.get('description', ''))
+    
+    for u, v, data in kg.graph.edges(data=True):
+        net.add_edge(u, v, title=data.get('relation_type', ''))
+    
+    net.show(output)
+    print(f"图谱已保存到: {output}")
+```
+
+## ⚠️ 常见问题
+
+### Q1: 实体提取质量不高？
+**A**: 
+- 调整LLM温度参数
+- 优化实体提取提示词
+- 使用更强大的LLM模型
+
+### Q2: 索引构建时间长？
+**A**:
+- 增大批处理大小
+- 减少文档数量进行测试
+- 使用缓存的索引文件
+
+### Q3: 查询结果不相关？
+**A**:
+- 检查实体识别是否准确
+- 调整查询策略（本地/全局）
+- 增加邻居跳数
+
+### Q4: 内存占用过大？
+**A**:
+- 使用更轻量的图数据库
+- 分批处理大文档集
+- 限制社区检测的迭代次数
+
+## 🔄 与现有系统集成
+
+### 修改现有 main.py
+
+```python
+from config import ENABLE_GRAPHRAG
+from graph_indexer import initialize_graph_indexer
+from graph_retriever import initialize_graph_retriever
+
+class AdaptiveRAGSystem:
+    def __init__(self):
+        # ... 现有初始化代码 ...
+        
+        # 添加GraphRAG支持
+        if ENABLE_GRAPHRAG:
+            self._setup_graphrag()
+    
+    def _setup_graphrag(self):
+        self.graph_indexer = initialize_graph_indexer()
+        # ... 索引构建 ...
+        self.graph_retriever = initialize_graph_retriever(self.knowledge_graph)
+    
+    def query(self, question: str):
+        # 混合使用向量检索和图谱查询
+        vector_docs = self.retriever.get_relevant_documents(question)
+        
+        if ENABLE_GRAPHRAG:
+            graph_answer = self.graph_retriever.smart_query(question)
+            # 融合两种结果
+            return self._merge_results(vector_docs, graph_answer)
+        
+        return self._generate_from_docs(vector_docs)
+```
+
+## 📚 参考资料
+
+- [Microsoft GraphRAG 论文](https://arxiv.org/abs/2404.16130)
+- [NetworkX 文档](https://networkx.org/)
+- [Louvain 社区检测算法](https://en.wikipedia.org/wiki/Louvain_method)
+
+## 🛣️ 未来增强
+
+- [ ] 增量索引更新
+- [ ] 多模态知识图谱
+- [ ] 图谱可视化界面
+- [ ] Neo4j集成（生产环境）
+- [ ] 知识图谱推理引擎
+- [ ] 实体链接优化
+- [ ] 自动实体消歧
+
+---
+
+**提示**: 首次使用建议先在小数据集上测试，验证效果后再应用到完整数据集。

GRAPHRAG_INTEGRATION_SUMMARY.md

@@ -0,0 +1,427 @@
+# GraphRAG 集成完成总结
+
+## ✅ 已完成的工作
+
+### 🆕 新增文件 (7个)
+
+| 文件 | 行数 | 主要功能 |
+|------|------|---------|
+| **entity_extractor.py** | 225 | 实体和关系提取、实体去重 |
+| **knowledge_graph.py** | 348 | 图谱构建、社区检测、摘要生成 |
+| **graph_indexer.py** | 146 | GraphRAG索引构建流程 |
+| **graph_retriever.py** | 276 | 本地/全局/智能查询 |
+| **main_graphrag.py** | 294 | 完整使用示例和交互界面 |
+| **requirements_graphrag.txt** | 32 | GraphRAG额外依赖 |
+| **GRAPHRAG_GUIDE.md** | 402 | 详细使用指南 |
+
+### 🔧 修改的文件 (3个)
+
+| 文件 | 修改内容 |
+|------|---------|
+| **config.py** | 添加7个GraphRAG配置参数 |
+| **document_processor.py** | 修改`setup_knowledge_base()`返回doc_splits |
+| **requirements.txt** | 添加networkx和python-louvain依赖 |
+
+---
+
+## 📋 文件修改详情
+
+### 1. config.py - 新增配置
+
+```python
+# GraphRAG配置
+ENABLE_GRAPHRAG = True
+GRAPHRAG_INDEX_PATH = "./data/knowledge_graph.json"
+GRAPHRAG_COMMUNITY_ALGORITHM = "louvain"
+GRAPHRAG_MAX_HOPS = 2
+GRAPHRAG_TOP_K_COMMUNITIES = 5
+GRAPHRAG_BATCH_SIZE = 10
+```
+
+### 2. document_processor.py - 函数修改
+
+```python
+# 修改前
+def setup_knowledge_base(self, urls=None):
+    ...
+    return vectorstore, retriever
+
+# 修改后  
+def setup_knowledge_base(self, urls=None, enable_graphrag=False):
+    ...
+    return vectorstore, retriever, doc_splits  # 新增返回doc_splits
+
+# 同步修改
+def initialize_document_processor():
+    ...
+    return processor, vectorstore, retriever, doc_splits  # 新增doc_splits
+```
+
+### 3. requirements.txt - 新增依赖
+
+```txt
+# GraphRAG相关（可选）
+networkx>=3.1
+python-louvain>=0.16
+```
+
+---
+
+## 🏗️ GraphRAG 架构概览
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                      文档处理层                               │
+│  document_processor.py → doc_splits                          │
+└────────────────────────┬────────────────────────────────────┘
+                         ↓
+┌─────────────────────────────────────────────────────────────┐
+│                   实体提取层                                  │
+│  entity_extractor.py                                         │
+│  ├── EntityExtractor (实体和关系提取)                         │
+│  └── EntityDeduplicator (实体去重)                           │
+└────────────────────────┬────────────────────────────────────┘
+                         ↓
+┌─────────────────────────────────────────────────────────────┐
+│                   图谱构建层                                  │
+│  knowledge_graph.py                                          │
+│  ├── KnowledgeGraph (图谱管理)                               │
+│  │   ├── NetworkX图结构                                      │
+│  │   ├── 社区检测 (Louvain/Greedy/LabelProp)                │
+│  │   └── 统计分析                                            │
+│  └── CommunitySummarizer (社区摘要)                          │
+└────────────────────────┬────────────────────────────────────┘
+                         ↓
+┌─────────────────────────────────────────────────────────────┐
+│                   索引构建层                                  │
+│  graph_indexer.py                                            │
+│  └── GraphRAGIndexer                                         │
+│      ├── 5步索引流程                                         │
+│      └── 图谱持久化                                          │
+└────────────────────────┬────────────────────────────────────┘
+                         ↓
+┌─────────────────────────────────────────────────────────────┐
+│                   检索查询层                                  │
+│  graph_retriever.py                                          │
+│  └── GraphRetriever                                          │
+│      ├── 本地查询 (Local Query)                              │
+│      ├── 全局查询 (Global Query)                             │
+│      ├── 混合查询 (Hybrid Query)                             │
+│      └── 智能查询 (Smart Query)                              │
+└────────────────────────┬────────────────────────────────────┘
+                         ↓
+┌─────────────────────────────────────────────────────────────┐
+│                   应用层                                      │
+│  main_graphrag.py                                            │
+│  └── AdaptiveRAGWithGraph                                    │
+│      ├── 5种查询模式                                         │
+│      ├── 统计信息展示                                        │
+│      └── 交互式界面                                          │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 🚀 使用流程
+
+### 方式1: 直接运行示例
+
+```bash
+# 1. 安装依赖
+pip install -r requirements.txt
+pip install -r requirements_graphrag.txt
+
+# 2. 运行GraphRAG示例
+python main_graphrag.py
+
+# 首次运行会自动构建索引，后续运行会加载缓存
+```
+
+### 方式2: 集成到现有代码
+
+```python
+# 在 main.py 中集成
+from config import ENABLE_GRAPHRAG, GRAPHRAG_INDEX_PATH
+from graph_indexer import initialize_graph_indexer
+from graph_retriever import initialize_graph_retriever
+
+class AdaptiveRAGSystem:
+    def __init__(self):
+        # ... 现有初始化 ...
+        
+        if ENABLE_GRAPHRAG:
+            # 构建/加载图谱
+            self.graph_indexer = initialize_graph_indexer()
+            
+            if os.path.exists(GRAPHRAG_INDEX_PATH):
+                self.kg = self.graph_indexer.load_index(GRAPHRAG_INDEX_PATH)
+            else:
+                self.kg = self.graph_indexer.index_documents(
+                    self.doc_splits,
+                    save_path=GRAPHRAG_INDEX_PATH
+                )
+            
+            # 初始化检索器
+            self.graph_retriever = initialize_graph_retriever(self.kg)
+    
+    def query(self, question: str):
+        if ENABLE_GRAPHRAG:
+            # 使用图谱智能查询
+            return self.graph_retriever.smart_query(question)
+        else:
+            # 原有逻辑
+            ...
+```
+
+---
+
+## 📊 功能对比
+
+### 原系统 vs GraphRAG增强
+
+| 功能 | 原系统 | GraphRAG增强 | 提升 |
+|------|--------|--------------|------|
+| **检索方式** | 向量相似度 | 向量 + 图谱 | ✅ 多模态检索 |
+| **关系理解** | ❌ 无 | ✅ 显式关系 | ✅ 关系推理能力 |
+| **多跳推理** | ❌ 有限 | ✅ 支持N跳 | ✅ 复杂推理 |
+| **全局理解** | ⚠️ 需读取多文档 | ✅ 社区摘要 | ✅ 高效概览 |
+| **实体消歧** | ❌ 无 | ✅ 图谱上下文 | ✅ 准确识别 |
+| **事实验证** | 基于文档匹配 | 基于关系验证 | ✅ 更严格 |
+
+---
+
+## 🎯 适用场景
+
+### GraphRAG特别适合:
+
+✅ **知识密集型领域**
+- 学术论文、技术文档
+- 需要理解实体关系
+- 例: "AlphaCodium的作者研究了哪些其他技术？"
+
+✅ **需要推理的问题**
+- 多跳关系查询
+- 因果关系分析
+- 例: "提示工程如何应用于对抗性攻击防御？"
+
+✅ **概览性问题**
+- 主题归纳
+- 研究趋势
+- 例: "这个领域的主要研究方向有哪些？"
+
+### 仍使用向量检索:
+
+⚠️ **模糊语义查询**
+- 没有明确实体
+- 需要语义相似匹配
+
+⚠️ **最新资讯查询**
+- 图谱未覆盖的新内容
+- 需要网络搜索
+
+---
+
+## 🔧 配置参数说明
+
+```python
+# config.py
+
+ENABLE_GRAPHRAG = True  
+# 是否启用GraphRAG，False则回退到纯向量检索
+
+GRAPHRAG_INDEX_PATH = "./data/knowledge_graph.json"
+# 图谱持久化路径，避免每次重建
+
+GRAPHRAG_COMMUNITY_ALGORITHM = "louvain"
+# 社区检测算法:
+# - "louvain": 最优质量（推荐）
+# - "greedy": 更快速度
+# - "label_propagation": 快速近似
+
+GRAPHRAG_MAX_HOPS = 2
+# 本地查询时扩展的邻居深度
+# 1: 只看直接邻居
+# 2: 二跳邻居（推荐）
+# 3+: 可能包含过多噪声
+
+GRAPHRAG_TOP_K_COMMUNITIES = 5
+# 全局查询时使用的社区数量
+# 更多社区 = 更全面但更慢
+
+GRAPHRAG_BATCH_SIZE = 10
+# 实体提取的批处理大小
+# 更大批次 = 更快但更耗内存
+```
+
+---
+
+## 📈 性能特征
+
+### 索引构建时间
+
+| 文档数量 | 实体数 | 关系数 | 社区数 | 构建时间* |
+|---------|--------|--------|--------|----------|
+| 10个文档块 | ~50 | ~30 | 3-5 | ~2分钟 |
+| 50个文档块 | ~200 | ~150 | 8-12 | ~8分钟 |
+| 100个文档块 | ~400 | ~300 | 15-20 | ~15分钟 |
+
+*基于Mistral模型，实际时间取决于LLM速度
+
+### 查询速度
+
+| 查询类型 | 平均耗时 | 说明 |
+|---------|---------|------|
+| 本地查询 | 2-5秒 | 需要LLM生成答案 |
+| 全局查询 | 3-8秒 | 需要处理多个社区摘要 |
+| 智能查询 | 2-8秒 | 取决于选择的策略 |
+| 混合查询 | 5-12秒 | 执行两种查询 |
+
+### 存储需求
+
+- **图谱索引**: 100个文档块 ≈ 1-5 MB (JSON格式)
+- **内存占用**: 运行时 ≈ 200-500 MB (取决于图大小)
+
+---
+
+## 🐛 故障排查
+
+### 问题1: 实体提取失败
+```
+❌ 实体提取失败: timeout
+```
+
+**解决方案**:
+- 检查Ollama服务是否运行: `ollama serve`
+- 减少批处理大小: `GRAPHRAG_BATCH_SIZE = 5`
+- 使用更快的LLM模型
+
+### 问题2: 社区检测失败
+```
+⚠️ python-louvain未安装
+```
+
+**解决方案**:
+```bash
+pip install python-louvain
+# 或使用其他算法
+GRAPHRAG_COMMUNITY_ALGORITHM = "greedy"
+```
+
+### 问题3: 查询无结果
+```
+未能在知识图谱中找到相关实体
+```
+
+**解决方案**:
+- 检查图谱是否构建: `rag_system.get_graph_statistics()`
+- 使用全局查询代替本地查询
+- 检查实体提取质量
+
+### 问题4: 内存不足
+```
+MemoryError
+```
+
+**解决方案**:
+- 减少文档数量测试
+- 增加批处理间隔
+- 使用轻量级图存储
+
+---
+
+## 📝 代码示例
+
+### 示例1: 基本使用
+
+```python
+from main_graphrag import AdaptiveRAGWithGraph
+
+# 初始化系统
+rag = AdaptiveRAGWithGraph(enable_graphrag=True)
+
+# 本地查询（针对特定实体）
+answer = rag.query_graph_local("LLM Agent的主要组件是什么？")
+
+# 全局查询（概览性问题）
+answer = rag.query_graph_global("这些文档讨论了哪些主题？")
+
+# 智能查询（自动选择策略）
+answer = rag.query_smart("如何防御对抗性攻击？")
+```
+
+### 示例2: 混合检索
+
+```python
+# 同时使用向量和图谱
+result = rag.query_hybrid("提示工程在LLM中的应用")
+
+print("向量检索:", result["vector_retrieval"]["context"])
+print("图谱本地:", result["graph_local"])
+print("图谱全局:", result["graph_global"])
+```
+
+### 示例3: 手动控制
+
+```python
+from graph_indexer import initialize_graph_indexer
+from graph_retriever import initialize_graph_retriever
+
+# 构建索引
+indexer = initialize_graph_indexer()
+kg = indexer.index_documents(documents, save_path="my_graph.json")
+
+# 查看统计
+stats = kg.get_statistics()
+print(f"实体: {stats['num_nodes']}, 关系: {stats['num_edges']}")
+
+# 查询
+retriever = initialize_graph_retriever(kg)
+answer = retriever.local_query("specific question", max_hops=3)
+```
+
+---
+
+## 🎓 学习资源
+
+### 推荐阅读顺序
+
+1. **GRAPHRAG_GUIDE.md** - 详细使用指南
+2. **entity_extractor.py** - 了解实体提取
+3. **knowledge_graph.py** - 理解图谱构建
+4. **graph_retriever.py** - 学习查询策略
+5. **main_graphrag.py** - 完整实践示例
+
+### 关键概念
+
+- **实体 (Entity)**: 图中的节点，如人物、概念、技术
+- **关系 (Relation)**: 图中的边，连接两个实体
+- **社区 (Community)**: 紧密连接的节点群组
+- **本地查询**: 基于实体邻域的精确查询
+- **全局查询**: 基于社区摘要的概览查询
+
+---
+
+## 🔮 未来计划
+
+- [ ] **增量索引**: 添加新文档无需重建整个图谱
+- [ ] **Neo4j集成**: 生产环境使用专业图数据库
+- [ ] **可视化界面**: Web界面展示知识图谱
+- [ ] **多模型融合**: 结合多个LLM提高提取质量
+- [ ] **实时更新**: 动态更新图谱结构
+- [ ] **知识推理**: 基于图谱的推理引擎
+- [ ] **性能优化**: 并行处理、缓存机制
+
+---
+
+## 📞 支持
+
+遇到问题？
+
+1. 查看 **GRAPHRAG_GUIDE.md** 的"常见问题"章节
+2. 检查日志输出中的错误信息
+3. 运行 `python main_graphrag.py` 测试基本功能
+4. 使用 `get_graph_statistics()` 检查图谱状态
+
+---
+
+**总结**: GraphRAG已成功集成到自适应RAG系统中，提供了从实体提取到智能查询的完整工作流。通过合理选择查询策略，可以显著提升复杂问题的回答质量。

QUICKSTART.md

@@ -0,0 +1,73 @@
+# 快速开始指南
+
+## 安装依赖
+
+```bash
+pip install -r requirements.txt
+```
+
+## 环境配置
+
+### 1. 设置API密钥
+
+复制 `.env.example` 文件为 `.env`：
+```bash
+cp .env.example .env
+```
+
+编辑 `.env` 文件，填入您的实际API密钥：
+```bash
+# Tavily API密钥 - 用于网络搜索功能
+# 从 https://tavily.com/ 获取
+TAVILY_API_KEY=your_actual_tavily_api_key
+
+# Nomic API密钥 - 用于文本嵌入服务
+# 从 https://atlas.nomic.ai/ 获取
+NOMIC_API_KEY=your_actual_nomic_api_key
+```
+
+### 2. 确保本地模型可用
+
+确保您已安装并运行Ollama，并下载了Mistral模型：
+```bash
+# 安装Ollama
+# 访问 https://ollama.ai/ 下载安装
+
+# 下载Mistral模型
+ollama pull mistral
+```
+
+## 运行系统
+
+```bash
+python main.py
+```
+
+## 项目结构
+
+```
+adaptive_RAG/
+├── config.py              # 配置和环境设置
+├── document_processor.py  # 文档处理和向量化
+├── routers_and_graders.py # 路由器和评分器
+├── workflow_nodes.py      # 工作流节点
+├── main.py                # 主应用程序入口
+├── requirements.txt       # 依赖管理
+├── README.md              # 项目说明
+└── QUICKSTART.md          # 快速开始指南
+```
+
+## 功能模块说明
+
+1. **config.py**: 包含所有配置项、API密钥管理和环境变量设置
+2. **document_processor.py**: 负责文档加载、分块、向量化和检索器设置
+3. **routers_and_graders.py**: 实现查询路由、文档评分、答案质量评估等功能
+4. **workflow_nodes.py**: 定义所有工作流节点和状态管理
+5. **main.py**: 系统集成和用户交互界面
+
+## 使用示例
+
+系统启动后会自动进入交互模式，你可以：
+- 询问关于LLM、提示工程、对抗性攻击的问题（使用本地知识库）
+- 询问其他问题（自动路由到网络搜索）
+- 输入 'quit' 或 'exit' 退出系统

README.md

@@ -0,0 +1,157 @@
+# 自适应检索增强生成系统
+
+## 📋 项目描述
+
+本项目实现了一个**自适应检索增强生成（Adaptive RAG）**系统，能够智能地在本地向量数据库检索和网络搜索之间路由用户查询。系统使用复杂的工作流程，通过自适应选择最佳信息源并通过文档评分和查询转换持续改进响应质量，以提供准确、上下文相关的答案。
+
+## ✨ 核心功能
+
+### 🔄 智能查询路由
+- 根据查询内容自动判断是使用本地向量存储还是网络搜索
+- 将关于LLM智能体、提示工程和对抗性攻击的问题路由到向量存储
+- 对于一般查询回退到网络搜索
+
+### 📚 高级文档处理
+- 使用tiktoken编码器进行网络内容加载和分块
+- 使用Nomic嵌入（本地推理）进行向量嵌入
+- Chroma向量数据库实现高效相似性搜索
+
+### 🎯 质量保证流水线
+- **文档相关性评分**：过滤与查询相关的检索文档
+- **答案质量评估**：评估生成的答案是否解决了问题
+- **幻觉检测**：确保回答基于源文档
+- **查询转换**：改进未产生满意结果的查询
+
+### 🌐 混合信息检索
+- 用于特定领域知识的本地向量数据库
+- 通过Tavily API集成网络搜索获取最新信息
+- 需要时无缝结合两种信息源
+
+## 🛠️ 技术栈
+
+### 核心框架
+- **LangChain**：LLM应用程序编排框架
+- **LangGraph**：复杂工作流的状态图实现
+
+### 语言模型
+- **Ollama**：本地LLM推理（Mistral模型）
+- **ChatOllama**：Ollama的LangChain集成
+
+### 向量数据库与嵌入
+- **Chroma**：用于文档存储和检索的向量数据库
+- **Nomic Embeddings**：本地文本嵌入模型（nomic-embed-text-v1.5）
+
+### 文档处理
+- **WebBaseLoader**：网络内容提取
+- **RecursiveCharacterTextSplitter**：使用tiktoken的智能文本分块
+
+### 外部API
+- **Tavily API**：网络搜索功能
+- **Nomic API**：嵌入服务
+
+### 工作流管理
+- **StateGraph**：管理复杂RAG工作流状态
+- **TypedDict**：类型安全的状态管理
+
+## 🏗️ 系统架构
+
+系统实现了一个包含以下组件的复杂状态机：
+
+```
+用户查询 → 路由器 → [向量存储 | 网络搜索]
+              ↓            ↓
+          检索文档      网络搜索
+              ↓            ↓
+          文档评分 --------→ 生成答案
+              ↓               ↓
+      [足够|不足够]      质量检查
+              ↓        ↓    ↓    ↓
+          生成答案   [有用] [无用] [不支持]
+              ↓        ↓     ↓      ↓
+          质量检查   [结束] 转换查询  重新生成
+              ↓              ↓      ↓
+      [有用|无用|不支持]     重新检索  ↑
+              ↓              ↓      |
+          [最终答案]     ←----------
+```
+
+### 工作流节点
+1. **retrieve**：从向量存储获取相关文档
+2. **web_search**：搜索网络获取最新信息
+3. **grade_documents**：评估文档相关性
+4. **generate**：使用RAG链创建答案
+5. **transform_query**：改进查询表述
+
+### 决策点
+- **route_question**：在向量存储和网络搜索之间选择
+- **decide_to_generate**：判断文档是否足够
+- **grade_generation**：验证答案质量和基础性
+
+## 📖 功能模块
+
+### 1. **环境设置**
+- 安全的API密钥管理
+- 本地LLM模型配置
+
+### 2. **知识库创建**
+- 从指定URL加载网络内容
+- 文档预处理和向量化
+- 向量数据库初始化
+
+### 3. **查询处理**
+- 基于内容分析的智能路由
+- 文档检索和相关性评分
+- 查询优化和转换
+
+### 4. **答案生成**
+- 上下文感知的响应生成
+- 多源信息综合
+- 质量验证和改进
+
+### 5. **质量控制**
+- 幻觉检测
+- 答案相关性评分
+- 迭代改进机制
+
+## 🚀 使用示例
+
+系统通过自适应工作流处理查询：
+
+```python
+# 查询处理示例
+inputs = {"question": "AlphaCodium论文讲的是什么？"}
+for output in app.stream(inputs):
+    for key, value in output.items():
+        print(f"节点 '{key}':")
+```
+
+## 📊 数据源
+
+### 默认知识库
+- LLM智能体（Lilian Weng的博客）
+- 提示工程技术
+- LLM对抗性攻击
+
+### 动态数据源
+- 实时网络搜索结果
+- 上下文相关的文档检索
+
+## 🔧 配置说明
+
+### 必需的API密钥
+- `TAVILY_API_KEY`：用于网络搜索功能
+- `NOMIC_API_KEY`：用于嵌入服务
+
+### 本地模型
+- **模型**：Mistral（通过Ollama）
+- **温度**：0（确定性响应）
+- **格式**：结构化输出的JSON
+
+## 💡 核心创新
+
+1. **自适应路由**：基于查询语义的动态源选择
+2. **多层验证**：文档相关性、答案质量和幻觉检查
+3. **自我改进查询**：自动查询转换以获得更好结果
+4. **混合架构**：本地和基于网络的信息源无缝集成
+
+这个自适应RAG系统代表了信息检索和生成的先进方法，通过智能工作流管理��持续质量评估确保高质量、相关的响应。

RERANKING_PRINCIPLES.md

@@ -0,0 +1,359 @@
+# 向量重排（Vector Reranking）原理详解
+
+## 🎯 什么是向量重排
+
+向量重排是检索增强生成（RAG）系统中的一种高级技术，用于在初始向量检索后对候选文档进行重新排序，以提高最终检索结果的质量和相关性。
+
+## 🔍 为什么需要重排
+
+### 初始检索的局限性
+
+1. **语义距离偏差**
+   - 向量相似度可能无法完全捕捉语义相关性
+   - 某些相关文档可能因为表达方式不同而排名靠后
+
+2. **上下文理解不足**
+   - 简单的余弦相似度无法理解复杂的查询意图
+   - 缺乏对查询和文档交互关系的深度理解
+
+3. **多样性问题**
+   - 初始检索可能返回内容相似的重复文档
+   - 缺乏结果的多样性和全面性
+
+## 🧠 重排的核心原理
+
+### 1. 双阶段检索架构
+
+```
+查询 → 粗排（向量检索）→ 精排（重排模型）→ 最终结果
+     ↓                  ↓
+   召回候选集        重新排序打分
+   (100-1000篇)      (选择前k篇)
+```
+
+### 2. 重排模型类型
+
+#### A. 交叉编码器（Cross-Encoder）
+```python
+# 原理示意
+def cross_encoder_rerank(query, documents):
+    scores = []
+    for doc in documents:
+        # 查询和文档一起编码
+        input_text = f"[CLS] {query} [SEP] {doc} [SEP]"
+        score = model(input_text)  # 直接输出相关性分数
+        scores.append(score)
+    return sorted(zip(documents, scores), key=lambda x: x[1], reverse=True)
+```
+
+#### B. 双编码器重排（Bi-Encoder Reranking）
+```python
+def bi_encoder_rerank(query, documents):
+    query_embedding = query_encoder(query)
+    doc_embeddings = [doc_encoder(doc) for doc in documents]
+    
+    # 使用更复杂的相似度计算
+    scores = []
+    for doc_emb in doc_embeddings:
+        score = complex_similarity(query_embedding, doc_emb)
+        scores.append(score)
+    return sorted(zip(documents, scores), key=lambda x: x[1], reverse=True)
+```
+
+## 🔬 重排算法详解
+
+### 1. 基于机器学习的重排
+
+#### Learning to Rank (LTR)
+```python
+class LearnToRankReranker:
+    def __init__(self):
+        self.model = None  # XGBoost, LambdaMART等
+    
+    def extract_features(self, query, document):
+        """提取查询-文档特征"""
+        features = [
+            # 文本匹配特征
+            jaccard_similarity(query, document),
+            tf_idf_score(query, document),
+            bm25_score(query, document),
+            
+            # 语义特征
+            cosine_similarity(query_emb, doc_emb),
+            bert_score(query, document),
+            
+            # 文档特征
+            document_length(document),
+            document_quality_score(document),
+            
+            # 查询特征
+            query_complexity(query),
+            query_type_classification(query)
+        ]
+        return features
+    
+    def rerank(self, query, documents):
+        features_matrix = []
+        for doc in documents:
+            features = self.extract_features(query, doc)
+            features_matrix.append(features)
+        
+        scores = self.model.predict(features_matrix)
+        return sorted(zip(documents, scores), key=lambda x: x[1], reverse=True)
+```
+
+### 2. 基于深度学习的重排
+
+#### Transformer重排模型
+```python
+class TransformerReranker:
+    def __init__(self, model_name="microsoft/DialoGPT-medium"):
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModelForSequenceClassification.from_pretrained(model_name)
+    
+    def rerank(self, query, documents, top_k=5):
+        scores = []
+        
+        for doc in documents:
+            # 构造输入
+            inputs = self.tokenizer(
+                query, doc,
+                padding=True,
+                truncation=True,
+                max_length=512,
+                return_tensors="pt"
+            )
+            
+            # 获取相关性分数
+            with torch.no_grad():
+                outputs = self.model(**inputs)
+                score = torch.softmax(outputs.logits, dim=-1)[0][1]  # 相关性概率
+                scores.append(score.item())
+        
+        # 重新排序
+        ranked_results = sorted(
+            zip(documents, scores), 
+            key=lambda x: x[1], 
+            reverse=True
+        )
+        
+        return ranked_results[:top_k]
+```
+
+### 3. 多策略融合重排
+
+```python
+class MultiStrategyReranker:
+    def __init__(self):
+        self.semantic_weight = 0.4
+        self.lexical_weight = 0.3
+        self.diversity_weight = 0.2
+        self.freshness_weight = 0.1
+    
+    def rerank(self, query, documents):
+        # 1. 语义相关性分数
+        semantic_scores = self.compute_semantic_scores(query, documents)
+        
+        # 2. 词汇匹配分数
+        lexical_scores = self.compute_lexical_scores(query, documents)
+        
+        # 3. 多样性分数
+        diversity_scores = self.compute_diversity_scores(documents)
+        
+        # 4. 时效性分数
+        freshness_scores = self.compute_freshness_scores(documents)
+        
+        # 5. 加权融合
+        final_scores = []
+        for i in range(len(documents)):
+            score = (
+                self.semantic_weight * semantic_scores[i] +
+                self.lexical_weight * lexical_scores[i] +
+                self.diversity_weight * diversity_scores[i] +
+                self.freshness_weight * freshness_scores[i]
+            )
+            final_scores.append(score)
+        
+        return sorted(zip(documents, final_scores), key=lambda x: x[1], reverse=True)
+```
+
+## 🎛️ 重排特征工程
+
+### 1. 文本匹配特征
+```python
+def extract_text_features(query, document):
+    return {
+        # 精确匹配
+        'exact_match_ratio': exact_match_count(query, document) / len(query.split()),
+        
+        # 模糊匹配
+        'fuzzy_match_score': fuzz.ratio(query, document) / 100,
+        
+        # N-gram重叠
+        'bigram_overlap': ngram_overlap(query, document, n=2),
+        'trigram_overlap': ngram_overlap(query, document, n=3),
+        
+        # TF-IDF相似度
+        'tfidf_similarity': tfidf_cosine_similarity(query, document),
+        
+        # BM25分数
+        'bm25_score': compute_bm25(query, document)
+    }
+```
+
+### 2. 语义特征
+```python
+def extract_semantic_features(query, document, embeddings):
+    query_emb = embeddings['query']
+    doc_emb = embeddings['document']
+    
+    return {
+        # 余弦相似度
+        'cosine_similarity': cosine_sim(query_emb, doc_emb),
+        
+        # 欧几里得距离
+        'euclidean_distance': euclidean_distance(query_emb, doc_emb),
+        
+        # 曼哈顿距离
+        'manhattan_distance': manhattan_distance(query_emb, doc_emb),
+        
+        # BERT分数
+        'bert_score': bert_score_f1(query, document),
+        
+        # 语义角度
+        'semantic_angle': semantic_angle(query_emb, doc_emb)
+    }
+```
+
+### 3. 文档质量特征
+```python
+def extract_quality_features(document):
+    return {
+        # 长度特征
+        'doc_length': len(document.split()),
+        'sentence_count': len(sent_tokenize(document)),
+        
+        # 可读性特征
+        'readability_score': textstat.flesch_reading_ease(document),
+        'complexity_score': textstat.flesch_kincaid_grade(document),
+        
+        # 信息密度
+        'unique_word_ratio': len(set(document.split())) / len(document.split()),
+        'stopword_ratio': stopword_count(document) / len(document.split()),
+        
+        # 结构特征
+        'has_headers': bool(re.search(r'^#+\s', document, re.MULTILINE)),
+        'has_lists': bool(re.search(r'^\s*[-*+]\s', document, re.MULTILINE))
+    }
+```
+
+## 🚀 实际应用示例
+
+### 集成到RAG系统中
+```python
+class AdaptiveRAGWithReranking:
+    def __init__(self):
+        self.initial_retriever = VectorRetriever()
+        self.reranker = TransformerReranker()
+        self.generator = LanguageModel()
+    
+    def query(self, question, top_k=5, rerank_candidates=20):
+        # 1. 初始检索（获取更多候选）
+        initial_docs = self.initial_retriever.retrieve(
+            question, 
+            top_k=rerank_candidates
+        )
+        
+        # 2. 重排
+        reranked_docs = self.reranker.rerank(
+            question, 
+            initial_docs, 
+            top_k=top_k
+        )
+        
+        # 3. 生成答案
+        context = "\n\n".join([doc[0] for doc in reranked_docs])
+        answer = self.generator.generate(question, context)
+        
+        return {
+            'answer': answer,
+            'sources': reranked_docs,
+            'confidence': self.calculate_confidence(reranked_docs)
+        }
+```
+
+## 📊 性能评估指标
+
+### 1. 排序质量指标
+```python
+def evaluate_reranking(original_ranking, reranked_results, ground_truth):
+    return {
+        # NDCG (Normalized Discounted Cumulative Gain)
+        'ndcg@5': ndcg_score(ground_truth, reranked_results, k=5),
+        'ndcg@10': ndcg_score(ground_truth, reranked_results, k=10),
+        
+        # MAP (Mean Average Precision)
+        'map': mean_average_precision(ground_truth, reranked_results),
+        
+        # MRR (Mean Reciprocal Rank)
+        'mrr': mean_reciprocal_rank(ground_truth, reranked_results),
+        
+        # 排序改进度
+        'ranking_improvement': kendall_tau(original_ranking, reranked_results)
+    }
+```
+
+### 2. 端到端效果评估
+```python
+def evaluate_rag_with_reranking(test_questions, ground_truth_answers):
+    results = []
+    
+    for question, gt_answer in zip(test_questions, ground_truth_answers):
+        # 无重排
+        original_answer = rag_without_rerank(question)
+        
+        # 有重排
+        reranked_answer = rag_with_rerank(question)
+        
+        results.append({
+            'question': question,
+            'original_score': evaluate_answer(original_answer, gt_answer),
+            'reranked_score': evaluate_answer(reranked_answer, gt_answer),
+            'improvement': evaluate_answer(reranked_answer, gt_answer) - 
+                          evaluate_answer(original_answer, gt_answer)
+        })
+    
+    return results
+```
+
+## 💡 最佳实践
+
+### 1. 重排策略选择
+- **实时性要求高**: 使用轻量级规则或简单ML模型
+- **精度要求高**: 使用深度学习重排模型
+- **平衡性能**: 多策略融合 + 缓存优化
+
+### 2. 特征选择原则
+- **相关性特征**: 语义相似度、词汇匹配
+- **质量特征**: 文档权威性、完整性
+- **多样性特征**: 避免结果冗余
+- **时效性特征**: 信息新鲜度
+
+### 3. 系统优化
+```python
+class OptimizedReranker:
+    def __init__(self):
+        self.cache = LRUCache(maxsize=1000)
+        self.batch_size = 32
+    
+    @lru_cache(maxsize=1000)
+    def cached_rerank(self, query_hash, doc_hashes):
+        """缓存重排结果"""
+        pass
+    
+    def batch_rerank(self, queries, documents):
+        """批量重排优化"""
+        pass
+```
+
+重排向量是提升RAG系统检索精度的关键技术，通过多层次的相关性评估和智能排序，显著提高了最终答案的质量和准确性。

colab_gpu_demo.ipynb

@@ -0,0 +1,588 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 🚀 GraphRAG GPU检测与测试 - Google Colab版本\n",
+    "\n",
+    "本Notebook用于在Google Colab上检测GPU可用性并测试GraphRAG系统的性能。\n",
+    "\n",
+    "## 📋 使用步骤\n",
+    "\n",
+    "1. **启用GPU**: 运行时 → 更改运行时类型 → 硬件加速器 → GPU (T4)\n",
+    "2. **运行所有单元格**: 依次执行下面的代码\n",
+    "3. **查看结果**: 检查GPU加速效果\n",
+    "\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1️⃣ GPU环境检测"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 检测GPU可用性\n",
+    "import torch\n",
+    "import subprocess\n",
+    "import sys\n",
+    "\n",
+    "print(\"=\"*60)\n",
+    "print(\"🔍 GPU环境检测\")\n",
+    "print(\"=\"*60)\n",
+    "\n",
+    "# PyTorch GPU检测\n",
+    "cuda_available = torch.cuda.is_available()\n",
+    "print(f\"\\n✅ CUDA可用: {cuda_available}\")\n",
+    "\n",
+    "if cuda_available:\n",
+    "    print(f\"   GPU数量: {torch.cuda.device_count()}\")\n",
+    "    print(f\"   当前GPU: {torch.cuda.current_device()}\")\n",
+    "    print(f\"   GPU名称: {torch.cuda.get_device_name(0)}\")\n",
+    "    print(f\"   CUDA版本: {torch.version.cuda}\")\n",
+    "    \n",
+    "    # 显存信息\n",
+    "    total_memory = torch.cuda.get_device_properties(0).total_memory / (1024**3)\n",
+    "    print(f\"   总显存: {total_memory:.2f} GB\")\n",
+    "    \n",
+    "    # nvidia-smi信息\n",
+    "    print(\"\\n📊 nvidia-smi 输出:\")\n",
+    "    print(\"-\"*60)\n",
+    "    !nvidia-smi\n",
+    "else:\n",
+    "    print(\"\\n⚠️  警告: 未检测到GPU\")\n",
+    "    print(\"   请检查: 运行时 → 更改运行时类型 → 硬件加速器 → GPU\")\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*60)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2️⃣ GPU性能基准测试"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# GPU vs CPU 性能对比\n",
+    "import time\n",
+    "import numpy as np\n",
+    "\n",
+    "print(\"=\"*60)\n",
+    "print(\"⚡ GPU vs CPU 矩阵运算性能测试\")\n",
+    "print(\"=\"*60)\n",
+    "\n",
+    "# 测试参数\n",
+    "matrix_size = 5000\n",
+    "\n",
+    "# CPU测试\n",
+    "print(f\"\\n🔵 CPU测试 (矩阵大小: {matrix_size}x{matrix_size})\")\n",
+    "a_cpu = torch.randn(matrix_size, matrix_size)\n",
+    "b_cpu = torch.randn(matrix_size, matrix_size)\n",
+    "\n",
+    "start = time.time()\n",
+    "c_cpu = torch.mm(a_cpu, b_cpu)\n",
+    "cpu_time = time.time() - start\n",
+    "print(f\"   CPU时间: {cpu_time:.2f} 秒\")\n",
+    "\n",
+    "# GPU测试\n",
+    "if cuda_available:\n",
+    "    print(f\"\\n🟢 GPU测试 (矩阵大小: {matrix_size}x{matrix_size})\")\n",
+    "    a_gpu = torch.randn(matrix_size, matrix_size).cuda()\n",
+    "    b_gpu = torch.randn(matrix_size, matrix_size).cuda()\n",
+    "    \n",
+    "    # 预热GPU\n",
+    "    _ = torch.mm(a_gpu, b_gpu)\n",
+    "    torch.cuda.synchronize()\n",
+    "    \n",
+    "    start = time.time()\n",
+    "    c_gpu = torch.mm(a_gpu, b_gpu)\n",
+    "    torch.cuda.synchronize()\n",
+    "    gpu_time = time.time() - start\n",
+    "    print(f\"   GPU时间: {gpu_time:.2f} 秒\")\n",
+    "    \n",
+    "    speedup = cpu_time / gpu_time\n",
+    "    print(f\"\\n🚀 加速比: {speedup:.2f}x\")\n",
+    "    print(f\"   GPU比CPU快 {speedup:.1f} 倍!\")\n",
+    "else:\n",
+    "    print(\"\\n⚠️  跳过GPU测试（GPU不可用）\")\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*60)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3️⃣ 安装GraphRAG依赖"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 克隆项目（如果需要）\n",
+    "import os\n",
+    "\n",
+    "print(\"📦 安装GraphRAG依赖...\\n\")\n",
+    "\n",
+    "# 安装核心依赖\n",
+    "!pip install -q langchain langchain-community langchain-core langgraph\n",
+    "!pip install -q chromadb sentence-transformers transformers\n",
+    "!pip install -q tiktoken beautifulsoup4 requests\n",
+    "!pip install -q tavily-python python-dotenv\n",
+    "!pip install -q networkx python-louvain\n",
+    "!pip install -q torch --index-url https://download.pytorch.org/whl/cu118\n",
+    "\n",
+    "print(\"\\n✅ 依赖安装完成!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4️⃣ 上传项目文件\n",
+    "\n",
+    "**选项A**: 从GitHub克隆\n",
+    "```python\n",
+    "!git clone https://github.com/your-repo/adaptive_RAG.git\n",
+    "%cd adaptive_RAG\n",
+    "```\n",
+    "\n",
+    "**选项B**: 手动上传文件到Colab\n",
+    "- 使用左侧文件浏览器上传以下核心文件：\n",
+    "  - `config.py`\n",
+    "  - `entity_extractor.py`\n",
+    "  - `knowledge_graph.py`\n",
+    "  - `graph_indexer.py`\n",
+    "  - `graph_retriever.py`\n",
+    "  - `.env` (包含API密钥)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 创建必要的目录\n",
+    "!mkdir -p data\n",
+    "\n",
+    "# 如果使用选项A，运行下面的命令\n",
+    "# !git clone YOUR_REPO_URL\n",
+    "# %cd adaptive_RAG\n",
+    "\n",
+    "print(\"✅ 目录准备完成\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5️⃣ 配置API密钥"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 设置API密钥（替换为您的真实密钥）\n",
+    "import os\n",
+    "from getpass import getpass\n",
+    "\n",
+    "print(\"🔑 配置API密钥\\n\")\n",
+    "\n",
+    "# 方式1: 直接设置（不安全，仅用于测试）\n",
+    "# os.environ['TAVILY_API_KEY'] = 'your_tavily_api_key_here'\n",
+    "\n",
+    "# 方式2: 安全输入\n",
+    "if 'TAVILY_API_KEY' not in os.environ:\n",
+    "    os.environ['TAVILY_API_KEY'] = getpass('输入 TAVILY_API_KEY: ')\n",
+    "    print(\"✅ TAVILY_API_KEY 已设置\")\n",
+    "else:\n",
+    "    print(\"✅ TAVILY_API_KEY 已存在\")\n",
+    "\n",
+    "print(\"\\n注意: GraphRAG在Colab上使用HuggingFace嵌入，不需要NOMIC_API_KEY\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 6️⃣ 简化版GraphRAG测试代码"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 简化版GraphRAG核心组件\n",
+    "# 适用于Colab快速测试，无需完整项目文件\n",
+    "\n",
+    "from typing import List, Dict\n",
+    "import networkx as nx\n",
+    "from sentence_transformers import SentenceTransformer\n",
+    "import torch\n",
+    "\n",
+    "class SimpleGraphRAG:\n",
+    "    \"\"\"简化版GraphRAG用于GPU性能测试\"\"\"\n",
+    "    \n",
+    "    def __init__(self, use_gpu=True):\n",
+    "        print(\"🚀 初始化SimpleGraphRAG...\")\n",
+    "        \n",
+    "        # 检测设备\n",
+    "        self.device = 'cuda' if use_gpu and torch.cuda.is_available() else 'cpu'\n",
+    "        print(f\"   设备: {self.device.upper()}\")\n",
+    "        \n",
+    "        # 加载嵌入模型\n",
+    "        print(f\"   加载嵌入模型...\")\n",
+    "        self.embedder = SentenceTransformer(\n",
+    "            'sentence-transformers/all-MiniLM-L6-v2',\n",
+    "            device=self.device\n",
+    "        )\n",
+    "        \n",
+    "        # 知识图谱\n",
+    "        self.graph = nx.Graph()\n",
+    "        self.entities = {}\n",
+    "        \n",
+    "        print(\"✅ 初始化完成!\")\n",
+    "    \n",
+    "    def add_sample_data(self):\n",
+    "        \"\"\"添加示例数据\"\"\"\n",
+    "        print(\"\\n📊 添加示例数据...\")\n",
+    "        \n",
+    "        # 示例实体\n",
+    "        entities = [\n",
+    "            {\"name\": \"LLM\", \"type\": \"CONCEPT\", \"desc\": \"大语言模型\"},\n",
+    "            {\"name\": \"GPT\", \"type\": \"TECHNOLOGY\", \"desc\": \"生成式预训练转换器\"},\n",
+    "            {\"name\": \"Transformer\", \"type\": \"CONCEPT\", \"desc\": \"注意力机制架构\"},\n",
+    "            {\"name\": \"OpenAI\", \"type\": \"ORGANIZATION\", \"desc\": \"人工智能研究公司\"},\n",
+    "            {\"name\": \"Attention\", \"type\": \"CONCEPT\", \"desc\": \"注意力机制\"},\n",
+    "        ]\n",
+    "        \n",
+    "        for entity in entities:\n",
+    "            self.graph.add_node(\n",
+    "                entity[\"name\"],\n",
+    "                type=entity[\"type\"],\n",
+    "                description=entity[\"desc\"]\n",
+    "            )\n",
+    "            self.entities[entity[\"name\"]] = entity\n",
+    "        \n",
+    "        # 示例关系\n",
+    "        relations = [\n",
+    "            (\"GPT\", \"LLM\", \"IS_A\"),\n",
+    "            (\"GPT\", \"Transformer\", \"USES\"),\n",
+    "            (\"Transformer\", \"Attention\", \"CONTAINS\"),\n",
+    "            (\"OpenAI\", \"GPT\", \"DEVELOPS\"),\n",
+    "        ]\n",
+    "        \n",
+    "        for source, target, rel_type in relations:\n",
+    "            self.graph.add_edge(source, target, relation=rel_type)\n",
+    "        \n",
+    "        print(f\"   ✅ 添加了 {len(entities)} 个实体\")\n",
+    "        print(f\"   ✅ 添加了 {len(relations)} 个关系\")\n",
+    "    \n",
+    "    def test_gpu_embedding(self, texts: List[str]):\n",
+    "        \"\"\"测试GPU嵌入性能\"\"\"\n",
+    "        print(f\"\\n⚡ 测试嵌入性能 ({len(texts)} 个文本)...\")\n",
+    "        \n",
+    "        import time\n",
+    "        \n",
+    "        start = time.time()\n",
+    "        embeddings = self.embedder.encode(\n",
+    "            texts,\n",
+    "            show_progress_bar=True,\n",
+    "            batch_size=32\n",
+    "        )\n",
+    "        elapsed = time.time() - start\n",
+    "        \n",
+    "        print(f\"   ✅ 完成! 耗时: {elapsed:.2f}秒\")\n",
+    "        print(f\"   📊 嵌入维度: {embeddings.shape}\")\n",
+    "        print(f\"   🚀 速度: {len(texts)/elapsed:.1f} 文本/秒\")\n",
+    "        \n",
+    "        return embeddings\n",
+    "    \n",
+    "    def query(self, question: str):\n",
+    "        \"\"\"简单查询\"\"\"\n",
+    "        print(f\"\\n🔍 查询: {question}\")\n",
+    "        \n",
+    "        # 简单的关键词匹配\n",
+    "        results = []\n",
+    "        for entity_name in self.entities:\n",
+    "            if entity_name.lower() in question.lower():\n",
+    "                neighbors = list(self.graph.neighbors(entity_name))\n",
+    "                results.append({\n",
+    "                    \"entity\": entity_name,\n",
+    "                    \"info\": self.entities[entity_name],\n",
+    "                    \"neighbors\": neighbors\n",
+    "                })\n",
+    "        \n",
+    "        print(f\"\\n📋 找到 {len(results)} 个相关实体:\")\n",
+    "        for r in results:\n",
+    "            print(f\"   • {r['entity']} ({r['info']['type']})\")\n",
+    "            print(f\"     描述: {r['info']['desc']}\")\n",
+    "            print(f\"     关联: {', '.join(r['neighbors'])}\")\n",
+    "        \n",
+    "        return results\n",
+    "\n",
+    "print(\"✅ SimpleGraphRAG类定义完成\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 7️⃣ 运行GPU性能测试"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 初始化GraphRAG（GPU版本）\n",
+    "print(\"=\"*60)\n",
+    "print(\"🎯 GraphRAG GPU性能测试\")\n",
+    "print(\"=\"*60)\n",
+    "\n",
+    "graph_rag = SimpleGraphRAG(use_gpu=True)\n",
+    "\n",
+    "# 添加示例数据\n",
+    "graph_rag.add_sample_data()\n",
+    "\n",
+    "# 准备测试文本\n",
+    "test_texts = [\n",
+    "    \"Large Language Models are transforming AI\",\n",
+    "    \"GPT uses Transformer architecture\",\n",
+    "    \"Attention mechanism is key to modern NLP\",\n",
+    "    \"OpenAI develops cutting-edge AI models\",\n",
+    "] * 25  # 100个文本\n",
+    "\n",
+    "print(f\"\\n准备了 {len(test_texts)} 个测试文本\")\n",
+    "\n",
+    "# GPU嵌入测试\n",
+    "embeddings = graph_rag.test_gpu_embedding(test_texts)\n",
+    "\n",
+    "# 测试查询\n",
+    "graph_rag.query(\"What is GPT?\")\n",
+    "graph_rag.query(\"Tell me about Transformer\")\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*60)\n",
+    "print(\"✅ GPU性能测试完成!\")\n",
+    "print(\"=\"*60)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 8️⃣ CPU vs GPU 性能对比"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# CPU vs GPU 嵌入性能对比\n",
+    "import time\n",
+    "\n",
+    "print(\"=\"*60)\n",
+    "print(\"📊 CPU vs GPU 嵌入性能对比\")\n",
+    "print(\"=\"*60)\n",
+    "\n",
+    "# 准备大量测试文本\n",
+    "large_test_texts = test_texts * 10  # 1000个文本\n",
+    "print(f\"\\n测试数据: {len(large_test_texts)} 个文本\\n\")\n",
+    "\n",
+    "# CPU测试\n",
+    "print(\"🔵 CPU测试...\")\n",
+    "graph_rag_cpu = SimpleGraphRAG(use_gpu=False)\n",
+    "start = time.time()\n",
+    "embeddings_cpu = graph_rag_cpu.embedder.encode(\n",
+    "    large_test_texts,\n",
+    "    show_progress_bar=False,\n",
+    "    batch_size=32\n",
+    ")\n",
+    "cpu_time = time.time() - start\n",
+    "print(f\"   CPU时间: {cpu_time:.2f}秒\")\n",
+    "print(f\"   速度: {len(large_test_texts)/cpu_time:.1f} 文本/秒\")\n",
+    "\n",
+    "# GPU测试\n",
+    "if cuda_available:\n",
+    "    print(\"\\n🟢 GPU测试...\")\n",
+    "    graph_rag_gpu = SimpleGraphRAG(use_gpu=True)\n",
+    "    start = time.time()\n",
+    "    embeddings_gpu = graph_rag_gpu.embedder.encode(\n",
+    "        large_test_texts,\n",
+    "        show_progress_bar=False,\n",
+    "        batch_size=32\n",
+    "    )\n",
+    "    gpu_time = time.time() - start\n",
+    "    print(f\"   GPU时间: {gpu_time:.2f}秒\")\n",
+    "    print(f\"   速度: {len(large_test_texts)/gpu_time:.1f} 文本/秒\")\n",
+    "    \n",
+    "    speedup = cpu_time / gpu_time\n",
+    "    print(f\"\\n🚀 加速比: {speedup:.2f}x\")\n",
+    "    print(f\"   GPU比CPU快 {speedup:.1f} 倍!\")\n",
+    "    \n",
+    "    # 节省的时间\n",
+    "    time_saved = cpu_time - gpu_time\n",
+    "    print(f\"   ⏱️  节省时间: {time_saved:.2f}秒\")\n",
+    "else:\n",
+    "    print(\"\\n⚠️  GPU不可用，跳过GPU测试\")\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*60)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 9️⃣ 显存使用监控"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 监控GPU显存使用\n",
+    "if cuda_available:\n",
+    "    print(\"=\"*60)\n",
+    "    print(\"💾 GPU显存使用情况\")\n",
+    "    print(\"=\"*60)\n",
+    "    \n",
+    "    allocated = torch.cuda.memory_allocated(0) / (1024**3)\n",
+    "    reserved = torch.cuda.memory_reserved(0) / (1024**3)\n",
+    "    total = torch.cuda.get_device_properties(0).total_memory / (1024**3)\n",
+    "    \n",
+    "    print(f\"\\n已分配: {allocated:.2f} GB\")\n",
+    "    print(f\"已保留: {reserved:.2f} GB\")\n",
+    "    print(f\"总显存: {total:.2f} GB\")\n",
+    "    print(f\"使用率: {(allocated/total)*100:.1f}%\")\n",
+    "    \n",
+    "    print(\"\\n详细信息:\")\n",
+    "    print(torch.cuda.memory_summary(0, abbreviated=True))\n",
+    "    \n",
+    "    print(\"\\n\" + \"=\"*60)\n",
+    "else:\n",
+    "    print(\"⚠️  GPU不可用\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 🔟 性能总结报告"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 生成性能报告\n",
+    "print(\"=\"*60)\n",
+    "print(\"📈 GraphRAG GPU性能测试报告\")\n",
+    "print(\"=\"*60)\n",
+    "\n",
+    "print(\"\\n🖥️  硬件信息:\")\n",
+    "if cuda_available:\n",
+    "    print(f\"   GPU型号: {torch.cuda.get_device_name(0)}\")\n",
+    "    print(f\"   显存: {torch.cuda.get_device_properties(0).total_memory / (1024**3):.2f} GB\")\n",
+    "    print(f\"   CUDA版本: {torch.version.cuda}\")\n",
+    "else:\n",
+    "    print(\"   ⚠️  GPU不可用\")\n",
+    "\n",
+    "print(f\"\\n   PyTorch版本: {torch.__version__}\")\n",
+    "print(f\"   Python版本: {sys.version.split()[0]}\")\n",
+    "\n",
+    "print(\"\\n⚡ 性能测试结果:\")\n",
+    "print(f\"   矩阵运算加速: ~{speedup if cuda_available else 'N/A'}x\")\n",
+    "print(f\"   文本嵌入加速: ~{cpu_time/gpu_time if cuda_available else 'N/A'}x\")\n",
+    "\n",
+    "print(\"\\n💡 建议:\")\n",
+    "if cuda_available:\n",
+    "    print(\"   ✅ GPU运行良好！建议在Colab上运行完整的GraphRAG索引构建\")\n",
+    "    print(\"   ✅ 预计索引构建时间将大幅缩短\")\n",
+    "    print(\"   ✅ 可以处理更大规模的文档集\")\n",
+    "else:\n",
+    "    print(\"   ⚠️  建议启用GPU以获得最佳性能\")\n",
+    "    print(\"   ⚠️  路径: 运行时 → 更改运行时类型 → GPU\")\n",
+    "\n",
+    "print(\"\\n\" + \"=\"*60)\n",
+    "print(\"✅ 测试完成!\")\n",
+    "print(\"=\"*60)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "\n",
+    "## 📚 下一步\n",
+    "\n",
+    "如果GPU测试成功，您可以：\n",
+    "\n",
+    "1. **上传完整项目**: 将整个adaptive_RAG项目上传到Colab\n",
+    "2. **运行GraphRAG索引**: 使用GPU加速构建知识图谱\n",
+    "3. **保存结果**: 将构建好的图谱下载到本地\n",
+    "\n",
+    "### 运行完整GraphRAG的命令:\n",
+    "\n",
+    "```python\n",
+    "# 上传项目后运行\n",
+    "!python main_graphrag.py\n",
+    "```\n",
+    "\n",
+    "### 预期加速效果:\n",
+    "\n",
+    "- 实体提取: 使用GPU的LLM推理会更快\n",
+    "- 文本嵌入: **5-10倍加速**\n",
+    "- 向量相似度计算: **10-20倍加速**\n",
+    "- 总体索引构建时间: **3-5倍加速**\n",
+    "\n",
+    "---"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.10.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

colab_gpu_test.py

@@ -0,0 +1,269 @@
+#!/usr/bin/env python3
+"""
+Google Colab GPU检测和GraphRAG性能测试脚本
+可以直接在Colab中运行：python colab_gpu_test.py
+"""
+
+import sys
+import time
+import torch
+import numpy as np
+from typing import List, Dict
+
+def print_section(title: str):
+    """打印分节标题"""
+    print("\n" + "="*60)
+    print(f"{title}")
+    print("="*60 + "\n")
+
+
+def test_gpu_availability():
+    """测试GPU可用性"""
+    print_section("🔍 GPU环境检测")
+    
+    cuda_available = torch.cuda.is_available()
+    print(f"✅ CUDA可用: {cuda_available}")
+    
+    if cuda_available:
+        print(f"   GPU数量: {torch.cuda.device_count()}")
+        print(f"   当前GPU: {torch.cuda.current_device()}")
+        print(f"   GPU名称: {torch.cuda.get_device_name(0)}")
+        print(f"   CUDA版本: {torch.version.cuda}")
+        
+        total_memory = torch.cuda.get_device_properties(0).total_memory / (1024**3)
+        print(f"   总显存: {total_memory:.2f} GB")
+        
+        return True
+    else:
+        print("\n⚠️  警告: 未检测到GPU")
+        print("   在Colab中启用GPU: 运行时 → 更改运行时类型 → GPU")
+        return False
+
+
+def benchmark_matrix_multiplication(matrix_size=5000):
+    """GPU vs CPU 矩阵运算性能测试"""
+    print_section("⚡ GPU vs CPU 矩阵运算性能测试")
+    
+    print(f"矩阵大小: {matrix_size}x{matrix_size}\n")
+    
+    # CPU测试
+    print("🔵 CPU测试...")
+    a_cpu = torch.randn(matrix_size, matrix_size)
+    b_cpu = torch.randn(matrix_size, matrix_size)
+    
+    start = time.time()
+    c_cpu = torch.mm(a_cpu, b_cpu)
+    cpu_time = time.time() - start
+    print(f"   CPU时间: {cpu_time:.2f} 秒")
+    
+    # GPU测试
+    if torch.cuda.is_available():
+        print("\n🟢 GPU测试...")
+        a_gpu = torch.randn(matrix_size, matrix_size).cuda()
+        b_gpu = torch.randn(matrix_size, matrix_size).cuda()
+        
+        # 预热GPU
+        _ = torch.mm(a_gpu, b_gpu)
+        torch.cuda.synchronize()
+        
+        start = time.time()
+        c_gpu = torch.mm(a_gpu, b_gpu)
+        torch.cuda.synchronize()
+        gpu_time = time.time() - start
+        print(f"   GPU时间: {gpu_time:.2f} 秒")
+        
+        speedup = cpu_time / gpu_time
+        print(f"\n🚀 加速比: {speedup:.2f}x")
+        print(f"   GPU比CPU快 {speedup:.1f} 倍!")
+        
+        return speedup
+    else:
+        print("\n⚠️  跳过GPU测试（GPU不可用）")
+        return 1.0
+
+
+def test_text_embedding_performance():
+    """测试文本嵌入性能（需要sentence-transformers）"""
+    print_section("📝 文本嵌入性能测试")
+    
+    try:
+        from sentence_transformers import SentenceTransformer
+        
+        # 准备测试数据
+        test_texts = [
+            "Large Language Models are transforming AI",
+            "GraphRAG combines knowledge graphs with retrieval",
+            "GPU acceleration significantly improves performance",
+            "Natural language processing is advancing rapidly",
+        ] * 250  # 1000个文本
+        
+        print(f"测试数据: {len(test_texts)} 个文本\n")
+        
+        # CPU测试
+        print("🔵 CPU嵌入测试...")
+        model_cpu = SentenceTransformer(
+            'sentence-transformers/all-MiniLM-L6-v2',
+            device='cpu'
+        )
+        start = time.time()
+        embeddings_cpu = model_cpu.encode(test_texts, show_progress_bar=False, batch_size=32)
+        cpu_time = time.time() - start
+        print(f"   CPU时间: {cpu_time:.2f}秒")
+        print(f"   速度: {len(test_texts)/cpu_time:.1f} 文本/秒")
+        
+        # GPU测试
+        if torch.cuda.is_available():
+            print("\n🟢 GPU嵌入测试...")
+            model_gpu = SentenceTransformer(
+                'sentence-transformers/all-MiniLM-L6-v2',
+                device='cuda'
+            )
+            start = time.time()
+            embeddings_gpu = model_gpu.encode(test_texts, show_progress_bar=False, batch_size=32)
+            gpu_time = time.time() - start
+            print(f"   GPU时间: {gpu_time:.2f}秒")
+            print(f"   速度: {len(test_texts)/gpu_time:.1f} 文本/秒")
+            
+            speedup = cpu_time / gpu_time
+            print(f"\n🚀 加速比: {speedup:.2f}x")
+            print(f"   节省时间: {cpu_time - gpu_time:.2f}秒")
+            
+            return speedup
+        else:
+            print("\n⚠️  跳过GPU测试")
+            return 1.0
+            
+    except ImportError:
+        print("⚠️  sentence-transformers未安装")
+        print("   安装: pip install sentence-transformers")
+        return None
+
+
+def monitor_gpu_memory():
+    """监控GPU显存使用"""
+    if not torch.cuda.is_available():
+        return
+    
+    print_section("💾 GPU显存使用情况")
+    
+    allocated = torch.cuda.memory_allocated(0) / (1024**3)
+    reserved = torch.cuda.memory_reserved(0) / (1024**3)
+    total = torch.cuda.get_device_properties(0).total_memory / (1024**3)
+    
+    print(f"已分配: {allocated:.2f} GB")
+    print(f"已保留: {reserved:.2f} GB")
+    print(f"总显存: {total:.2f} GB")
+    print(f"使用率: {(allocated/total)*100:.1f}%")
+
+
+def generate_performance_report(matrix_speedup, embedding_speedup):
+    """生成性能报告"""
+    print_section("📈 性能测试总结报告")
+    
+    print("🖥️  硬件信息:")
+    if torch.cuda.is_available():
+        print(f"   GPU型号: {torch.cuda.get_device_name(0)}")
+        print(f"   显存: {torch.cuda.get_device_properties(0).total_memory / (1024**3):.2f} GB")
+        print(f"   CUDA版本: {torch.version.cuda}")
+    else:
+        print("   ⚠️  GPU不可用")
+    
+    print(f"\n   PyTorch版本: {torch.__version__}")
+    print(f"   Python版本: {sys.version.split()[0]}")
+    
+    print("\n⚡ 性能测试结果:")
+    print(f"   矩阵运算加速: {matrix_speedup:.2f}x")
+    if embedding_speedup:
+        print(f"   文本嵌入加速: {embedding_speedup:.2f}x")
+    
+    print("\n💡 建议:")
+    if torch.cuda.is_available():
+        print("   ✅ GPU运行良好！")
+        print("   ✅ 建议在Colab上运行完整的GraphRAG索引构建")
+        print("   ✅ 预计索引构建时间将缩短 3-5 倍")
+        
+        # 估算时间节省
+        if embedding_speedup and embedding_speedup > 1:
+            print(f"\n⏱️  时间节省估算:")
+            print(f"   100文档CPU耗时: ~15分钟")
+            print(f"   100文档GPU耗时: ~{15/embedding_speedup:.1f}分钟")
+            print(f"   节省: ~{15 - 15/embedding_speedup:.1f}分钟")
+    else:
+        print("   ⚠️  建议启用GPU以获得最佳性能")
+        print("   ⚠️  Colab启用GPU: 运行时 → 更改运行时类型 → GPU")
+
+
+def install_dependencies():
+    """安装必要的依赖（仅在Colab中）"""
+    try:
+        import google.colab
+        is_colab = True
+    except:
+        is_colab = False
+    
+    if is_colab:
+        print_section("📦 安装依赖")
+        print("检测到Colab环境，安装必要的包...\n")
+        
+        import subprocess
+        packages = [
+            'sentence-transformers',
+            'networkx',
+            'python-louvain',
+        ]
+        
+        for package in packages:
+            try:
+                __import__(package.replace('-', '_'))
+                print(f"✅ {package} 已安装")
+            except ImportError:
+                print(f"📥 安装 {package}...")
+                subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q', package])
+                print(f"✅ {package} 安装完成")
+
+
+def main():
+    """主函数"""
+    print("\n" + "="*60)
+    print("🚀 Google Colab GPU检测和GraphRAG性能测试")
+    print("="*60)
+    
+    # 检查是否在Colab中运行
+    try:
+        import google.colab
+        print("\n✅ 运行环境: Google Colab")
+    except:
+        print("\n⚠️  警告: 未检测到Colab环境")
+        print("   本脚本专为Google Colab设计")
+    
+    # 安装依赖
+    install_dependencies()
+    
+    # 1. GPU检测
+    gpu_available = test_gpu_availability()
+    
+    # 2. 矩阵运算性能测试
+    matrix_speedup = benchmark_matrix_multiplication(matrix_size=5000)
+    
+    # 3. 文本嵌入性能测试
+    embedding_speedup = test_text_embedding_performance()
+    
+    # 4. 显存监控
+    if gpu_available:
+        monitor_gpu_memory()
+    
+    # 5. 生成报告
+    generate_performance_report(matrix_speedup, embedding_speedup)
+    
+    print("\n" + "="*60)
+    print("✅ 测试完成!")
+    print("="*60)
+    
+    print("\n📚 下一步:")
+    print("   1. 如果GPU测试成功，可以上传完整的adaptive_RAG项目")
+    print("   2. 运行 main_graphrag.py 进行完整的知识图谱构建")
+    print("   3. 享受GPU带来的3-5倍速度提升!")
+
+
+if __name__ == "__main__":
+    main()

colab_quick_test.py

@@ -0,0 +1,278 @@
+#!/usr/bin/env python3
+"""
+Google Colab一键GPU测试脚本
+复制此文件内容到Colab单元格中直接运行
+
+使用方法:
+1. 在Colab中创建新笔记本
+2. 启用GPU (运行时 → 更改运行时类型 → GPU)
+3. 复制并运行此脚本
+"""
+
+# ============================================================
+# 🔧 自动安装依赖
+# ============================================================
+print("📦 检查并安装依赖...")
+import subprocess
+import sys
+
+def install(package):
+    subprocess.check_call([sys.executable, "-m", "pip", "install", "-q", package])
+
+# 检查必要的包
+required_packages = {
+    'torch': 'torch',
+    'sentence_transformers': 'sentence-transformers',
+    'networkx': 'networkx',
+    'numpy': 'numpy'
+}
+
+for import_name, package_name in required_packages.items():
+    try:
+        __import__(import_name)
+        print(f"✅ {package_name} 已安装")
+    except ImportError:
+        print(f"📥 安装 {package_name}...")
+        install(package_name)
+
+print("\n" + "="*70)
+print("🚀 Google Colab GPU性能测试 - GraphRAG加速验证")
+print("="*70)
+
+# ============================================================
+# 1️⃣ GPU检测
+# ============================================================
+import torch
+import time
+
+print("\n" + "="*70)
+print("🔍 步骤1: GPU环境检测")
+print("="*70)
+
+cuda_available = torch.cuda.is_available()
+print(f"\n{'✅' if cuda_available else '❌'} CUDA可用: {cuda_available}")
+
+if cuda_available:
+    print(f"   📊 GPU型号: {torch.cuda.get_device_name(0)}")
+    print(f"   💾 显存大小: {torch.cuda.get_device_properties(0).total_memory / (1024**3):.2f} GB")
+    print(f"   🔢 CUDA版本: {torch.version.cuda}")
+    print(f"   📈 PyTorch版本: {torch.__version__}")
+else:
+    print("\n⚠️  GPU未启用！")
+    print("   请按照以下步骤启用GPU:")
+    print("   1. 点击顶部菜单 '运行时'")
+    print("   2. 选择 '更改运行时类型'")
+    print("   3. 硬件加速器选择 'GPU'")
+    print("   4. 点击 '保存'")
+    print("   5. 重新运行此单元格")
+    print("\n⚠️  测试将继续，但GPU相关测试会被跳过")
+
+# ============================================================
+# 2️⃣ 矩阵运算性能测试
+# ============================================================
+print("\n" + "="*70)
+print("⚡ 步骤2: 矩阵运算性能测试")
+print("="*70)
+
+matrix_size = 5000
+print(f"\n测试配置: {matrix_size}x{matrix_size} 矩阵乘法\n")
+
+# CPU测试
+print("🔵 CPU性能测试...")
+a_cpu = torch.randn(matrix_size, matrix_size)
+b_cpu = torch.randn(matrix_size, matrix_size)
+
+start = time.time()
+c_cpu = torch.mm(a_cpu, b_cpu)
+cpu_time = time.time() - start
+
+print(f"   ⏱️  CPU耗时: {cpu_time:.3f}秒")
+
+# GPU测试
+if cuda_available:
+    print("\n🟢 GPU性能测试...")
+    a_gpu = torch.randn(matrix_size, matrix_size).cuda()
+    b_gpu = torch.randn(matrix_size, matrix_size).cuda()
+    
+    # 预热
+    _ = torch.mm(a_gpu, b_gpu)
+    torch.cuda.synchronize()
+    
+    start = time.time()
+    c_gpu = torch.mm(a_gpu, b_gpu)
+    torch.cuda.synchronize()
+    gpu_time = time.time() - start
+    
+    print(f"   ⏱️  GPU耗时: {gpu_time:.3f}秒")
+    
+    speedup = cpu_time / gpu_time
+    print(f"\n   🚀 性能提升: {speedup:.1f}x")
+    print(f"   💡 GPU比CPU快 {speedup:.1f} 倍!")
+    
+    matrix_speedup = speedup
+else:
+    print("\n⚠️  跳过GPU测试")
+    matrix_speedup = 1.0
+
+# ============================================================
+# 3️⃣ 文本嵌入性能测试
+# ============================================================
+print("\n" + "="*70)
+print("📝 步骤3: 文本嵌入性能测试 (GraphRAG核心组件)")
+print("="*70)
+
+try:
+    from sentence_transformers import SentenceTransformer
+    
+    # 准备测试数据
+    test_texts = [
+        "GraphRAG combines knowledge graphs with retrieval augmented generation",
+        "GPU acceleration significantly improves machine learning performance",
+        "Large language models benefit from efficient embedding computation",
+        "Knowledge graph construction requires entity and relation extraction",
+    ] * 250  # 1000条文本
+    
+    print(f"\n测试配置: {len(test_texts)}条文本嵌入\n")
+    
+    # CPU嵌入
+    print("🔵 CPU嵌入测试...")
+    model_cpu = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2', device='cpu')
+    
+    start = time.time()
+    embeddings_cpu = model_cpu.encode(test_texts, show_progress_bar=False, batch_size=32)
+    cpu_emb_time = time.time() - start
+    
+    print(f"   ⏱️  CPU耗时: {cpu_emb_time:.2f}秒")
+    print(f"   📊 处理速度: {len(test_texts)/cpu_emb_time:.1f} 文本/秒")
+    
+    # GPU嵌入
+    if cuda_available:
+        print("\n🟢 GPU嵌入测试...")
+        model_gpu = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2', device='cuda')
+        
+        start = time.time()
+        embeddings_gpu = model_gpu.encode(test_texts, show_progress_bar=False, batch_size=32)
+        gpu_emb_time = time.time() - start
+        
+        print(f"   ⏱️  GPU耗时: {gpu_emb_time:.2f}秒")
+        print(f"   📊 处理速度: {len(test_texts)/gpu_emb_time:.1f} 文本/秒")
+        
+        emb_speedup = cpu_emb_time / gpu_emb_time
+        print(f"\n   🚀 性能提升: {emb_speedup:.1f}x")
+        print(f"   ⏱️  节省时间: {cpu_emb_time - gpu_emb_time:.2f}秒")
+    else:
+        print("\n⚠️  跳过GPU测试")
+        emb_speedup = 1.0
+        
+except ImportError:
+    print("\n⚠️  sentence-transformers未安装，跳过此测试")
+    emb_speedup = None
+
+# ============================================================
+# 4️⃣ GraphRAG场景模拟
+# ============================================================
+print("\n" + "="*70)
+print("🔍 步骤4: GraphRAG实际场景模拟")
+print("="*70)
+
+if cuda_available and emb_speedup:
+    print("\n模拟GraphRAG索引构建过程...\n")
+    
+    # 假设100个文档块的索引构建
+    documents_count = 100
+    
+    # 实体提取时间 (每个文档约1秒)
+    entity_extraction_time = documents_count * 1.0
+    
+    # 文本嵌入时间 (基于实际测试)
+    # 假设每个文档平均产生10个实体，共1000个实体需要嵌入
+    entities_count = documents_count * 10
+    
+    cpu_total_time = entity_extraction_time + (entities_count / (len(test_texts)/cpu_emb_time))
+    gpu_total_time = entity_extraction_time + (entities_count / (len(test_texts)/gpu_emb_time))
+    
+    print(f"📊 场景: {documents_count}个文档的GraphRAG索引构建\n")
+    print(f"🔵 CPU预计时间:")
+    print(f"   - 实体提取: {entity_extraction_time/60:.1f}分钟")
+    print(f"   - 向量嵌入: {(entities_count / (len(test_texts)/cpu_emb_time))/60:.1f}分钟")
+    print(f"   - 总计: {cpu_total_time/60:.1f}分钟")
+    
+    print(f"\n🟢 GPU预计时间:")
+    print(f"   - 实体提取: {entity_extraction_time/60:.1f}分钟 (相同)")
+    print(f"   - 向量嵌入: {(entities_count / (len(test_texts)/gpu_emb_time))/60:.1f}分钟")
+    print(f"   - 总计: {gpu_total_time/60:.1f}分钟")
+    
+    total_speedup = cpu_total_time / gpu_total_time
+    time_saved = (cpu_total_time - gpu_total_time) / 60
+    
+    print(f"\n🚀 整体加速: {total_speedup:.1f}x")
+    print(f"⏱️  节省时间: {time_saved:.1f}分钟")
+
+# ============================================================
+# 5️⃣ GPU显存监控
+# ============================================================
+if cuda_available:
+    print("\n" + "="*70)
+    print("💾 步骤5: GPU显存使用监控")
+    print("="*70)
+    
+    allocated = torch.cuda.memory_allocated(0) / (1024**3)
+    reserved = torch.cuda.memory_reserved(0) / (1024**3)
+    total = torch.cuda.get_device_properties(0).total_memory / (1024**3)
+    
+    print(f"\n   已分配: {allocated:.2f} GB")
+    print(f"   已保留: {reserved:.2f} GB")
+    print(f"   总显存: {total:.2f} GB")
+    print(f"   使用率: {(allocated/total)*100:.1f}%")
+
+# ============================================================
+# 6️⃣ 性能总结
+# ============================================================
+print("\n" + "="*70)
+print("📈 最终性能报告")
+print("="*70)
+
+print("\n🖥️  硬件配置:")
+if cuda_available:
+    print(f"   GPU: {torch.cuda.get_device_name(0)}")
+    print(f"   显存: {torch.cuda.get_device_properties(0).total_memory / (1024**3):.1f} GB")
+    print(f"   CUDA: {torch.version.cuda}")
+else:
+    print("   ⚠️  GPU未启用")
+
+print(f"\n⚡ 性能测试结果:")
+print(f"   矩阵运算加速: {matrix_speedup:.1f}x")
+if emb_speedup:
+    print(f"   文本嵌入加速: {emb_speedup:.1f}x")
+    if cuda_available:
+        print(f"   GraphRAG整体加速: {total_speedup:.1f}x")
+
+print("\n💡 结论和建议:")
+if cuda_available:
+    print("   ✅ GPU性能测试成功!")
+    print("   ✅ 强烈建议在Colab GPU环境运行GraphRAG")
+    print(f"   ✅ 预计可节省 {time_saved:.0f}+ 分钟的索引构建时间")
+    print("\n📚 下一步:")
+    print("   1. 上传adaptive_RAG项目文件到Colab")
+    print("   2. 运行 main_graphrag.py 构建完整知识图谱")
+    print("   3. 下载结果到本地使用")
+else:
+    print("   ⚠️  请启用GPU以获得最佳性能")
+    print("   ⚠️  路径: 运行时 → 更改运行时类型 → GPU")
+
+print("\n" + "="*70)
+print("✅ 测试完成! 感谢使用GraphRAG GPU测试工具")
+print("="*70)
+
+# ============================================================
+# 7️⃣ 可选: 显示nvidia-smi
+# ============================================================
+if cuda_available:
+    print("\n📊 nvidia-smi 详细信息:")
+    print("="*70)
+    import subprocess
+    try:
+        result = subprocess.run(['nvidia-smi'], capture_output=True, text=True)
+        print(result.stdout)
+    except:
+        print("⚠️  无法执行nvidia-smi命令")

colab_setup_and_run.py

@@ -0,0 +1,375 @@
+#!/usr/bin/env python3
+"""
+Google Colab环境下的GraphRAG完整运行脚本
+解决Ollama服务启动和GraphRAG运行的问题
+
+使用方法:
+1. 在Colab中启用GPU
+2. 复制此文件到Colab
+3. 运行: !python colab_setup_and_run.py
+"""
+
+import os
+import sys
+import time
+import subprocess
+import signal
+from pathlib import Path
+
+print("="*70)
+print("🚀 GraphRAG Colab 自动化部署脚本")
+print("="*70)
+
+# ============================================================
+# 1️⃣ 检测Colab环境
+# ============================================================
+def check_colab_environment():
+    """检测是否在Colab环境中"""
+    try:
+        import google.colab
+        print("\n✅ 运行环境: Google Colab")
+        return True
+    except ImportError:
+        print("\n⚠️  警告: 未检测到Colab环境")
+        print("   本脚本为Colab优化，在其他环境可能需要调整")
+        return False
+
+# ============================================================
+# 2️⃣ 安装Ollama
+# ============================================================
+def install_ollama():
+    """在Colab中安装Ollama"""
+    print("\n" + "="*70)
+    print("📦 步骤1: 安装Ollama")
+    print("="*70)
+    
+    # 检查是否已安装
+    if os.path.exists("/usr/local/bin/ollama"):
+        print("✅ Ollama已安装")
+        return True
+    
+    print("\n📥 下载并安装Ollama...")
+    try:
+        # 下载Ollama安装脚本
+        subprocess.run(
+            ["curl", "-fsSL", "https://ollama.com/install.sh", "-o", "/tmp/install_ollama.sh"],
+            check=True,
+            capture_output=True
+        )
+        
+        # 执行安装
+        subprocess.run(
+            ["sh", "/tmp/install_ollama.sh"],
+            check=True,
+            capture_output=True
+        )
+        
+        print("✅ Ollama安装成功")
+        return True
+        
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Ollama安装失败: {e}")
+        return False
+
+# ============================================================
+# 3️⃣ 后台启动Ollama服务
+# ============================================================
+def start_ollama_service():
+    """在后台启动Ollama服务"""
+    print("\n" + "="*70)
+    print("🔧 步骤2: 启动Ollama服务")
+    print("="*70)
+    
+    print("\n🔄 在后台启动Ollama服务...")
+    
+    # 方法1: 使用subprocess后台运行
+    try:
+        # 启动Ollama服务（后台）
+        ollama_process = subprocess.Popen(
+            ["ollama", "serve"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            preexec_fn=os.setpgrp  # 创建新的进程组
+        )
+        
+        # 等待服务启动
+        print("⏳ 等待Ollama服务启动...")
+        time.sleep(5)
+        
+        # 检查服务是否运行
+        try:
+            result = subprocess.run(
+                ["curl", "-s", "http://localhost:11434/api/tags"],
+                capture_output=True,
+                timeout=3
+            )
+            
+            if result.returncode == 0:
+                print("✅ Ollama服务已启动 (PID: {})".format(ollama_process.pid))
+                
+                # 保存进程ID以便后续管理
+                with open("/tmp/ollama.pid", "w") as f:
+                    f.write(str(ollama_process.pid))
+                
+                return ollama_process
+            else:
+                print("⚠️  服务启动可能有问题，继续尝试...")
+                
+        except subprocess.TimeoutExpired:
+            print("⚠️  服务检查超时，但进程已启动")
+            return ollama_process
+            
+    except Exception as e:
+        print(f"❌ 启动Ollama失败: {e}")
+        return None
+
+# ============================================================
+# 4️⃣ 下载Mistral模型
+# ============================================================
+def pull_mistral_model():
+    """下载Mistral模型"""
+    print("\n" + "="*70)
+    print("📥 步骤3: 下载Mistral模型")
+    print("="*70)
+    
+    print("\n🔄 拉取mistral模型（这可能需要几分钟）...")
+    
+    try:
+        # 检查模型是否已存在
+        result = subprocess.run(
+            ["ollama", "list"],
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        
+        if "mistral" in result.stdout:
+            print("✅ Mistral模型已存在")
+            return True
+        
+        # 下载模型
+        print("📥 开始下载Mistral模型...")
+        process = subprocess.Popen(
+            ["ollama", "pull", "mistral"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True
+        )
+        
+        # 实时显示下载进度
+        for line in process.stdout:
+            print(f"   {line.strip()}")
+        
+        process.wait()
+        
+        if process.returncode == 0:
+            print("✅ Mistral模型下载完成")
+            return True
+        else:
+            print("❌ 模型下载失败")
+            return False
+            
+    except Exception as e:
+        print(f"❌ 下载Mistral模型失败: {e}")
+        return False
+
+# ============================================================
+# 5️⃣ 安装Python依赖
+# ============================================================
+def install_python_dependencies():
+    """安装GraphRAG所需的Python包"""
+    print("\n" + "="*70)
+    print("📦 步骤4: 安装Python依赖")
+    print("="*70)
+    
+    packages = [
+        "langchain",
+        "langchain-community",
+        "langchain-core",
+        "langgraph",
+        "langchain-ollama",
+        "chromadb",
+        "sentence-transformers",
+        "tiktoken",
+        "beautifulsoup4",
+        "requests",
+        "tavily-python",
+        "python-dotenv",
+        "networkx",
+        "python-louvain",
+        "torch",
+        "transformers"
+    ]
+    
+    print("\n📥 安装必要的Python包...")
+    for package in packages:
+        try:
+            __import__(package.replace("-", "_"))
+            print(f"✅ {package} 已安装")
+        except ImportError:
+            print(f"📥 安装 {package}...")
+            subprocess.run(
+                [sys.executable, "-m", "pip", "install", "-q", package],
+                check=True
+            )
+    
+    print("\n✅ 所有依赖安装完成")
+
+# ============================================================
+# 6️⃣ 配置环境变量
+# ============================================================
+def setup_environment():
+    """配置环境变量"""
+    print("\n" + "="*70)
+    print("🔑 步骤5: 配置环境变量")
+    print("="*70)
+    
+    # 检查.env文件
+    if os.path.exists(".env"):
+        print("\n✅ 发现.env文件，加载配置...")
+        from dotenv import load_dotenv
+        load_dotenv()
+    else:
+        print("\n⚠️  未找到.env文件")
+        
+        # 交互式输入API密钥
+        if "TAVILY_API_KEY" not in os.environ:
+            from getpass import getpass
+            api_key = getpass("请输入TAVILY_API_KEY (或按Enter跳过): ")
+            if api_key:
+                os.environ["TAVILY_API_KEY"] = api_key
+                print("✅ TAVILY_API_KEY已设置")
+            else:
+                print("⚠️  跳过TAVILY_API_KEY设置（网络搜索功能将不可用）")
+    
+    print("\n📋 当前环境变量:")
+    print(f"   TAVILY_API_KEY: {'已设置' if os.environ.get('TAVILY_API_KEY') else '未设置'}")
+
+# ============================================================
+# 7️⃣ 运行GraphRAG
+# ============================================================
+def run_graphrag():
+    """运行GraphRAG主程序"""
+    print("\n" + "="*70)
+    print("🚀 步骤6: 运行GraphRAG")
+    print("="*70)
+    
+    # 检查main_graphrag.py是否存在
+    if not os.path.exists("main_graphrag.py"):
+        print("\n❌ 未找到main_graphrag.py文件")
+        print("   请确保已上传项目文件到Colab")
+        return False
+    
+    print("\n🔄 启动GraphRAG索引构建...\n")
+    
+    try:
+        # 运行GraphRAG
+        result = subprocess.run(
+            [sys.executable, "main_graphrag.py"],
+            capture_output=False,  # 实时输出
+            text=True
+        )
+        
+        if result.returncode == 0:
+            print("\n✅ GraphRAG运行成功!")
+            return True
+        else:
+            print(f"\n❌ GraphRAG运行失败 (返回码: {result.returncode})")
+            return False
+            
+    except KeyboardInterrupt:
+        print("\n⚠️  用户中断执行")
+        return False
+    except Exception as e:
+        print(f"\n❌ 运行GraphRAG时出错: {e}")
+        return False
+
+# ============================================================
+# 8️⃣ 清理函数
+# ============================================================
+def cleanup():
+    """清理后台进程"""
+    print("\n" + "="*70)
+    print("🧹 清理后台进程")
+    print("="*70)
+    
+    # 停止Ollama服务
+    if os.path.exists("/tmp/ollama.pid"):
+        try:
+            with open("/tmp/ollama.pid", "r") as f:
+                pid = int(f.read().strip())
+            
+            os.kill(pid, signal.SIGTERM)
+            print(f"✅ Ollama服务已停止 (PID: {pid})")
+            os.remove("/tmp/ollama.pid")
+            
+        except Exception as e:
+            print(f"⚠️  停止Ollama服务失败: {e}")
+
+# ============================================================
+# 主函数
+# ============================================================
+def main():
+    """主执行流程"""
+    ollama_process = None
+    
+    try:
+        # 1. 检测环境
+        is_colab = check_colab_environment()
+        
+        # 2. 安装Ollama
+        if not install_ollama():
+            print("\n❌ Ollama安装失败，无法继续")
+            return
+        
+        # 3. 启动Ollama服务
+        ollama_process = start_ollama_service()
+        if not ollama_process:
+            print("\n❌ Ollama服务启动失败，无法继续")
+            return
+        
+        # 4. 下载模型
+        if not pull_mistral_model():
+            print("\n❌ Mistral模型下载失败，无法继续")
+            return
+        
+        # 5. 安装Python依赖
+        install_python_dependencies()
+        
+        # 6. 配置环境
+        setup_environment()
+        
+        # 7. 运行GraphRAG
+        success = run_graphrag()
+        
+        if success:
+            print("\n" + "="*70)
+            print("✅ 所有任务完成!")
+            print("="*70)
+            
+            print("\n📊 生成的文件:")
+            if os.path.exists("data/knowledge_graph.json"):
+                print("   ✅ data/knowledge_graph.json")
+                
+                # 提供下载选项
+                if is_colab:
+                    print("\n💾 下载结果:")
+                    print("   from google.colab import files")
+                    print("   files.download('data/knowledge_graph.json')")
+        
+    except KeyboardInterrupt:
+        print("\n\n⚠️  用户中断执行")
+        
+    except Exception as e:
+        print(f"\n❌ 执行过程中出错: {e}")
+        import traceback
+        traceback.print_exc()
+        
+    finally:
+        # 清理
+        print("\n⚠️  注意: Ollama服务仍在后台运行")
+        print("   如需停止: !pkill -f 'ollama serve'")
+        print("   或运行: cleanup()")
+
+if __name__ == "__main__":
+    main()

config.py

@@ -0,0 +1,87 @@
+"""
+配置和环境设置模块
+包含API密钥管理、模型配置和URL配置
+"""
+
+import getpass
+import os
+
+# 尝试加载.env文件，如果没有安装dotenv则跳过
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+    print("✅ .env文件已加载")
+except ImportError:
+    print("⚠️  python-dotenv未安装，将使用系统环境变量")
+    print("提示：运行 'pip install python-dotenv' 来安装")
+
+
+def _set_env(var: str):
+    """设置环境变量，优先从.env文件读取，如果不存在则提示用户输入"""
+    if not os.environ.get(var):
+        os.environ[var] = getpass.getpass(f"{var}: ")
+
+
+def setup_environment():
+    """设置所有必需的环境变量"""
+    _set_env("TAVILY_API_KEY")
+    # 不再需要NOMIC_API_KEY，使用HuggingFace本地嵌入
+    
+    # 验证API密钥是否已设置
+    tavily_key = os.environ.get("TAVILY_API_KEY")
+    
+    if tavily_key:
+        print("✅ TAVILY_API_KEY 已从环境变量中加载")
+    else:
+        print("⚠️  TAVILY_API_KEY 未找到")
+
+
+# 模型配置
+LOCAL_LLM = "mistral"
+
+# 知识库URL配置
+KNOWLEDGE_BASE_URLS = [
+    "https://lilianweng.github.io/posts/2023-06-23-agent/",
+    "https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/",
+    "https://lilianweng.github.io/posts/2023-10-25-adv-attack-llm/",
+]
+
+# 文档分块配置
+CHUNK_SIZE = 250
+CHUNK_OVERLAP = 0
+
+# 向量数据库配置
+COLLECTION_NAME = "rag-chroma"
+EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"  # HuggingFace嵌入模型
+
+# 搜索配置
+WEB_SEARCH_RESULTS_COUNT = 3
+
+# GraphRAG配置
+ENABLE_GRAPHRAG = True  # 是否启用GraphRAG功能
+GRAPHRAG_INDEX_PATH = "./data/knowledge_graph.json"  # 图谱索引保存路径
+GRAPHRAG_COMMUNITY_ALGORITHM = "louvain"  # 社区检测算法: louvain, greedy, label_propagation
+GRAPHRAG_MAX_HOPS = 2  # 本地查询最大跳数
+GRAPHRAG_TOP_K_COMMUNITIES = 5  # 全局查询使用的社区数量
+GRAPHRAG_BATCH_SIZE = 10  # 实体提取批处理大小
+
+
+def get_api_keys():
+    """获取API密钥并返回字典"""
+    return {
+        "tavily": os.environ.get("TAVILY_API_KEY")
+    }
+
+
+def validate_api_keys():
+    """验证API密钥是否已设置"""
+    keys = get_api_keys()
+    missing_keys = []
+    
+    if not keys["tavily"]:
+        missing_keys.append("TAVILY_API_KEY")
+    
+    if missing_keys:
+        raise ValueError(f"缺少必需的API密钥: {', '.join(missing_keys)}\n请在.env文件中设置这些密钥")
+    
+    return True

deploy_gpu.sh

@@ -0,0 +1,240 @@
+#!/bin/bash
+# GPU部署脚本 - 一键部署自适应RAG系统到Linux RTX 4090环境
+
+set -e  # 遇到错误立即退出
+
+echo "🚀 开始部署自适应RAG系统到GPU环境..."
+
+# 颜色定义
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# 检查是否为root用户
+if [[ $EUID -eq 0 ]]; then
+   echo -e "${RED}请不要使用root用户运行此脚本${NC}"
+   exit 1
+fi
+
+# 检查GPU
+check_gpu() {
+    echo "🔍 检查GPU环境..."
+    if command -v nvidia-smi &> /dev/null; then
+        echo -e "${GREEN}✅ 发现NVIDIA GPU:${NC}"
+        nvidia-smi --query-gpu=name,memory.total --format=csv,noheader
+    else
+        echo -e "${RED}❌ 未发现NVIDIA GPU或驱动未安装${NC}"
+        exit 1
+    fi
+}
+
+# 检查CUDA
+check_cuda() {
+    echo "🔍 检查CUDA环境..."
+    if command -v nvcc &> /dev/null; then
+        echo -e "${GREEN}✅ CUDA版本:${NC}"
+        nvcc --version | grep "release"
+    else
+        echo -e "${YELLOW}⚠️ CUDA未安装或未添加到PATH${NC}"
+    fi
+}
+
+# 安装Docker
+install_docker() {
+    if ! command -v docker &> /dev/null; then
+        echo "📦 安装Docker..."
+        curl -fsSL https://get.docker.com -o get-docker.sh
+        sudo sh get-docker.sh
+        sudo usermod -aG docker $USER
+        rm get-docker.sh
+        echo -e "${GREEN}✅ Docker安装完成${NC}"
+    else
+        echo -e "${GREEN}✅ Docker已安装${NC}"
+    fi
+}
+
+# 安装NVIDIA Container Toolkit
+install_nvidia_docker() {
+    if ! docker run --rm --gpus all nvidia/cuda:11.0.3-base-ubuntu20.04 nvidia-smi &> /dev/null; then
+        echo "🐳 安装NVIDIA Container Toolkit..."
+        distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
+        curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
+        curl -s -L https://nvidia.github.io/libnvidia-container/$distribution/libnvidia-container.list | \
+                sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
+                sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
+        
+        sudo apt-get update
+        sudo apt-get install -y nvidia-container-toolkit
+        sudo systemctl restart docker
+        echo -e "${GREEN}✅ NVIDIA Container Toolkit安装完成${NC}"
+    else
+        echo -e "${GREEN}✅ NVIDIA Container Toolkit已配置${NC}"
+    fi
+}
+
+# 创建环境配置
+setup_env() {
+    echo "⚙️ 配置环境变量..."
+    if [ ! -f .env ]; then
+        cp .env.example .env
+        echo -e "${YELLOW}⚠️ 请编辑 .env 文件并设置您的API密钥${NC}"
+        echo "   - TAVILY_API_KEY: 从 https://tavily.com/ 获取"
+        read -p "按回车键继续..."
+    fi
+}
+
+# 选择部署方式
+choose_deployment() {
+    echo "🎯 选择部署方式:"
+    echo "1) Docker Compose部署 (推荐)"
+    echo "2) 直接Python部署"
+    read -p "请选择 (1-2): " choice
+    
+    case $choice in
+        1)
+            deploy_docker
+            ;;
+        2)
+            deploy_python
+            ;;
+        *)
+            echo -e "${RED}无效选择${NC}"
+            exit 1
+            ;;
+    esac
+}
+
+# Docker部署
+deploy_docker() {
+    echo "🐳 使用Docker Compose部署..."
+    
+    # 安装docker-compose
+    if ! command -v docker-compose &> /dev/null; then
+        echo "安装Docker Compose..."
+        sudo curl -L "https://github.com/docker/compose/releases/download/v2.20.0/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
+        sudo chmod +x /usr/local/bin/docker-compose
+    fi
+    
+    # 构建并启动服务
+    echo "构建镜像..."
+    docker-compose -f docker-compose.gpu.yml build
+    
+    echo "启动服务..."
+    docker-compose -f docker-compose.gpu.yml up -d
+    
+    echo -e "${GREEN}✅ Docker部署完成!${NC}"
+    echo "访问: http://localhost:8000"
+    echo "监控: http://localhost:9445 (GPU监控)"
+    echo "日志: docker-compose -f docker-compose.gpu.yml logs -f"
+}
+
+# Python直接部署
+deploy_python() {
+    echo "🐍 使用Python直接部署..."
+    
+    # 检查Python
+    if ! command -v python3 &> /dev/null; then
+        echo "安装Python3..."
+        sudo apt-get update
+        sudo apt-get install -y python3 python3-pip python3-venv
+    fi
+    
+    # 创建虚拟环境
+    if [ ! -d "rag_env" ]; then
+        echo "创建Python虚拟环境..."
+        python3 -m venv rag_env
+    fi
+    
+    # 激活虚拟环境并安装依赖
+    source rag_env/bin/activate
+    pip install --upgrade pip
+    pip install -r requirements_gpu.txt
+    
+    # 安装Ollama
+    if ! command -v ollama &> /dev/null; then
+        echo "安装Ollama..."
+        curl -fsSL https://ollama.ai/install.sh | sh
+    fi
+    
+    # 启动Ollama服务
+    echo "启动Ollama服务..."
+    ollama serve &
+    sleep 5
+    
+    # 下载模型
+    echo "下载Mistral模型..."
+    ollama pull mistral
+    
+    # 创建启动脚本
+    cat > start_gpu.sh << 'EOF'
+#!/bin/bash
+export CUDA_VISIBLE_DEVICES=0
+export PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:512
+export TOKENIZERS_PARALLELISM=false
+source rag_env/bin/activate
+python main.py
+EOF
+    chmod +x start_gpu.sh
+    
+    echo -e "${GREEN}✅ Python部署完成!${NC}"
+    echo "启动命令: ./start_gpu.sh"
+}
+
+# 验证部署
+verify_deployment() {
+    echo "🔍 验证部署..."
+    sleep 10
+    
+    if curl -f http://localhost:8000/health 2>/dev/null; then
+        echo -e "${GREEN}✅ 服务运行正常${NC}"
+    else
+        echo -e "${YELLOW}⚠️ 服务可能还在启动中，请稍后检查${NC}"
+    fi
+    
+    # 显示GPU使用情况
+    echo "📊 GPU状态:"
+    nvidia-smi --query-gpu=utilization.gpu,memory.used,memory.total --format=csv,noheader,nounits
+}
+
+# 显示部署信息
+show_info() {
+    echo ""
+    echo "🎉 部署完成!"
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo "📊 服务地址:"
+    echo "   - 主服务: http://localhost:8000"
+    echo "   - Ollama: http://localhost:11434"
+    echo ""
+    echo "🔧 常用命令:"
+    echo "   - 查看日志: docker-compose -f docker-compose.gpu.yml logs -f"
+    echo "   - 重启服务: docker-compose -f docker-compose.gpu.yml restart"
+    echo "   - 停止服务: docker-compose -f docker-compose.gpu.yml down"
+    echo "   - GPU监控: watch -n 1 nvidia-smi"
+    echo ""
+    echo "📚 文档位置:"
+    echo "   - 部署指南: DEPLOYMENT_GUIDE.md"
+    echo "   - 快速开始: QUICKSTART.md"
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+}
+
+# 主函数
+main() {
+    echo "🤖 自适应RAG系统 GPU部署脚本"
+    echo "适用于: Linux + RTX 4090"
+    echo ""
+    
+    check_gpu
+    check_cuda
+    install_docker
+    install_nvidia_docker
+    setup_env
+    choose_deployment
+    verify_deployment
+    show_info
+}
+
+# 运行主函数
+main "$@"
+
+reactive

docker-compose.gpu.yml

@@ -0,0 +1,70 @@
+# Docker Compose配置文件 - GPU部署
+version: '3.8'
+
+services:
+  adaptive-rag:
+    build:
+      context: .
+      dockerfile: Dockerfile.gpu
+    container_name: adaptive-rag-gpu
+    restart: unless-stopped
+    environment:
+      - CUDA_VISIBLE_DEVICES=0
+      - PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:512
+      - TOKENIZERS_PARALLELISM=false
+      - HF_HOME=/app/models
+      - TRANSFORMERS_CACHE=/app/models
+    env_file:
+      - .env
+    ports:
+      - "8000:8000"
+      - "8001:8001"  # 可选：监控端口
+    volumes:
+      - ./data:/app/data
+      - ./models:/app/models
+      - ./logs:/app/logs
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: 1
+              capabilities: [gpu]
+    depends_on:
+      - ollama
+
+  ollama:
+    image: ollama/ollama:latest
+    container_name: ollama-gpu
+    restart: unless-stopped
+    ports:
+      - "11434:11434"
+    volumes:
+      - ollama-data:/root/.ollama
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: 1
+              capabilities: [gpu]
+    command: ["ollama", "serve"]
+
+  # 可选：监控服务
+  nvidia-smi-exporter:
+    image: mindprince/nvidia_gpu_prometheus_exporter:0.1
+    container_name: gpu-monitor
+    restart: unless-stopped
+    ports:
+      - "9445:9445"
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: 1
+              capabilities: [gpu]
+
+volumes:
+  ollama-data:
+    driver: local

document_processor.py

@@ -0,0 +1,195 @@
+"""
+文档处理和向量化模块
+负责文档加载、文本分块、向量化和向量数据库初始化
+"""
+
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.document_loaders import WebBaseLoader
+from langchain_community.vectorstores import Chroma
+from langchain_community.embeddings import HuggingFaceEmbeddings
+
+from config import (
+    KNOWLEDGE_BASE_URLS,
+    CHUNK_SIZE,
+    CHUNK_OVERLAP,
+    COLLECTION_NAME,
+    EMBEDDING_MODEL
+)
+from reranker import create_reranker
+
+
+class DocumentProcessor:
+    """文档处理器类，负责文档加载、处理和向量化"""
+    
+    def __init__(self):
+        self.text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(
+            chunk_size=CHUNK_SIZE, 
+            chunk_overlap=CHUNK_OVERLAP
+        )
+        
+        # Try to initialize embeddings with error handling
+        try:
+            import torch
+            device = 'cuda' if torch.cuda.is_available() else 'cpu'
+            print(f"✅ 检测到设备: {device}")
+            if device == 'cuda':
+                print(f"   GPU型号: {torch.cuda.get_device_name(0)}")
+                print(f"   GPU内存: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f}GB")
+            
+            self.embeddings = HuggingFaceEmbeddings(
+                model_name="sentence-transformers/all-MiniLM-L6-v2",  # 轻量级嵌入模型
+                model_kwargs={'device': device},  # 自动选择GPU或CPU
+                encode_kwargs={'normalize_embeddings': True}  # 标准化嵌入向量
+            )
+            print(f"✅ HuggingFace嵌入模型初始化成功 (设备: {device})")
+        except Exception as e:
+            print(f"⚠️ HuggingFace嵌入初始化失败: {e}")
+            print("正在尝试备用嵌入方案...")
+            # Fallback to OpenAI embeddings or other alternatives
+            from langchain_community.embeddings import FakeEmbeddings
+            self.embeddings = FakeEmbeddings(size=384)  # For testing purposes
+            print("✅ 使用测试嵌入模型")
+            
+        self.vectorstore = None
+        self.retriever = None
+        
+        # 初始化重排器
+        self.reranker = None
+        self._setup_reranker()
+    
+    def _setup_reranker(self):
+        """设置重排器"""
+        try:
+            # 使用混合重排器获得最佳效果
+            self.reranker = create_reranker('hybrid', self.embeddings)
+            print("✅ 重排器初始化成功")
+        except Exception as e:
+            print(f"⚠️ 重排器初始化失败: {e}")
+            print("将使用基础检索，不进行重排")
+    
+    def load_documents(self, urls=None):
+        """从URL加载文档"""
+        if urls is None:
+            urls = KNOWLEDGE_BASE_URLS
+        
+        print(f"正在加载 {len(urls)} 个URL的文档...")
+        docs = [WebBaseLoader(url).load() for url in urls]
+        docs_list = [item for sublist in docs for item in sublist]
+        print(f"成功加载 {len(docs_list)} 个文档")
+        return docs_list
+    
+    def split_documents(self, docs):
+        """将文档分割成块"""
+        print("正在分割文档...")
+        doc_splits = self.text_splitter.split_documents(docs)
+        print(f"文档分割完成，共 {len(doc_splits)} 个文档块")
+        return doc_splits
+    
+    def create_vectorstore(self, doc_splits):
+        """创建向量数据库"""
+        print("正在创建向量数据库...")
+        self.vectorstore = Chroma.from_documents(
+            documents=doc_splits,
+            collection_name=COLLECTION_NAME,
+            embedding=self.embeddings,
+        )
+        self.retriever = self.vectorstore.as_retriever()
+        print("向量数据库创建完成")
+        return self.vectorstore, self.retriever
+    
+    def setup_knowledge_base(self, urls=None, enable_graphrag=False):
+        """设置完整的知识库（加载、分割、向量化）
+        
+        Args:
+            urls: 文档URL列表
+            enable_graphrag: 是否启用GraphRAG索引
+            
+        Returns:
+            vectorstore, retriever, doc_splits
+        """
+        docs = self.load_documents(urls)
+        doc_splits = self.split_documents(docs)
+        vectorstore, retriever = self.create_vectorstore(doc_splits)
+        
+        # 返回doc_splits用于GraphRAG索引
+        return vectorstore, retriever, doc_splits
+    
+    def enhanced_retrieve(self, query: str, top_k: int = 5, rerank_candidates: int = 20):
+        """增强检索：先检索更多候选，然后重排"""
+        if not self.retriever:
+            print("⚠️ 检索器未初始化")
+            return []
+        
+        # 1. 初始检索：获取更多候选文档
+        initial_docs = self.retriever.get_relevant_documents(query)
+        
+        # 获取更多候选（如果可能）
+        if hasattr(self.retriever, 'search_kwargs'):
+            # 修改检索参数以获取更多结果
+            original_k = self.retriever.search_kwargs.get('k', 4)
+            self.retriever.search_kwargs['k'] = min(rerank_candidates, len(initial_docs))
+            candidate_docs = self.retriever.get_relevant_documents(query)
+            self.retriever.search_kwargs['k'] = original_k  # 恢复原设置
+        else:
+            candidate_docs = initial_docs
+        
+        print(f"初始检索获得 {len(candidate_docs)} 个候选文档")
+        
+        # 2. 重排（如果重排器可用）
+        if self.reranker and len(candidate_docs) > top_k:
+            try:
+                reranked_results = self.reranker.rerank(query, candidate_docs, top_k)
+                final_docs = [doc for doc, score in reranked_results]
+                scores = [score for doc, score in reranked_results]
+                
+                print(f"重排后返回 {len(final_docs)} 个文档")
+                print(f"重排分数范围: {min(scores):.4f} - {max(scores):.4f}")
+                
+                return final_docs
+            except Exception as e:
+                print(f"⚠️ 重排失败: {e}，使用原始检索结果")
+                return candidate_docs[:top_k]
+        else:
+            # 不重排或候选数量不足
+            return candidate_docs[:top_k]
+    
+    def compare_retrieval_methods(self, query: str, top_k: int = 5):
+        """比较不同检索方法的效果"""
+        if not self.retriever:
+            return {}
+        
+        # 原始检索
+        original_docs = self.retriever.get_relevant_documents(query)[:top_k]
+        
+        # 增强检索（带重排）
+        enhanced_docs = self.enhanced_retrieve(query, top_k)
+        
+        return {
+            'query': query,
+            'original_retrieval': {
+                'count': len(original_docs),
+                'documents': [{
+                    'content': doc.page_content[:200] + '...' if len(doc.page_content) > 200 else doc.page_content,
+                    'metadata': getattr(doc, 'metadata', {})
+                } for doc in original_docs]
+            },
+            'enhanced_retrieval': {
+                'count': len(enhanced_docs),
+                'documents': [{
+                    'content': doc.page_content[:200] + '...' if len(doc.page_content) > 200 else doc.page_content,
+                    'metadata': getattr(doc, 'metadata', {})
+                } for doc in enhanced_docs]
+            },
+            'reranker_used': self.reranker is not None
+        }
+
+    def format_docs(self, docs):
+        """格式化文档用于生成"""
+        return "\n\n".join(doc.page_content for doc in docs)
+
+
+def initialize_document_processor():
+    """初始化文档处理器并设置知识库"""
+    processor = DocumentProcessor()
+    vectorstore, retriever, doc_splits = processor.setup_knowledge_base()
+    return processor, vectorstore, retriever, doc_splits

entity_extractor.py

@@ -0,0 +1,229 @@
+"""
+实体和关系提取模块
+使用LLM从文档中提取实体、关系和属性，构建知识图谱的基础
+"""
+
+from typing import List, Dict, Tuple
+from langchain.prompts import PromptTemplate
+from langchain_community.chat_models import ChatOllama
+from langchain_core.output_parsers import JsonOutputParser
+from config import LOCAL_LLM
+
+
+class EntityExtractor:
+    """实体提取器 - 使用LLM从文本中提取实体"""
+    
+    def __init__(self):
+        self.llm = ChatOllama(model=LOCAL_LLM, format="json", temperature=0)
+        
+        # 实体提取提示模板
+        self.entity_prompt = PromptTemplate(
+            template="""你是一个专业的实体识别专家。从以下文本中提取所有重要的实体。
+            
+实体类型包括:
+- PERSON: 人物、作者、研究者
+- ORGANIZATION: 组织、机构、公司
+- CONCEPT: 技术概念、算法、方法论
+- TECHNOLOGY: 具体技术、工具、框架
+- PAPER: 论文、出版物
+- EVENT: 事件、会议
+
+文本内容:
+{text}
+
+请以JSON格式返回，包含以下字段:
+{{
+    "entities": [
+        {{
+            "name": "实体名称",
+            "type": "实体类型",
+            "description": "简短描述"
+        }}
+    ]
+}}
+
+不要包含前言或解释，只返回JSON。
+""",
+            input_variables=["text"]
+        )
+        
+        # 关系提取提示模板
+        self.relation_prompt = PromptTemplate(
+            template="""你是一个关系抽取专家。从文本中识别实体之间的关系。
+
+已识别的实体:
+{entities}
+
+文本内容:
+{text}
+
+请识别实体之间的关系，以JSON格式返回:
+{{
+    "relations": [
+        {{
+            "source": "源实体名称",
+            "target": "目标实体名称",
+            "relation_type": "关系类型",
+            "description": "关系描述"
+        }}
+    ]
+}}
+
+关系类型包括: AUTHOR_OF, USES, BASED_ON, RELATED_TO, PART_OF, APPLIES_TO, IMPROVES, CITES
+
+不要包含前言或解释，只返回JSON。
+""",
+            input_variables=["text", "entities"]
+        )
+        
+        self.entity_chain = self.entity_prompt | self.llm | JsonOutputParser()
+        self.relation_chain = self.relation_prompt | self.llm | JsonOutputParser()
+    
+    def extract_entities(self, text: str) -> List[Dict]:
+        """
+        从文本中提取实体
+        
+        Args:
+            text: 输入文本
+            
+        Returns:
+            实体列表
+        """
+        try:
+            result = self.entity_chain.invoke({"text": text[:2000]})  # 限制长度
+            entities = result.get("entities", [])
+            print(f"✅ 提取到 {len(entities)} 个实体")
+            return entities
+        except Exception as e:
+            print(f"❌ 实体提取失败: {e}")
+            return []
+    
+    def extract_relations(self, text: str, entities: List[Dict]) -> List[Dict]:
+        """
+        从文本中提取实体关系
+        
+        Args:
+            text: 输入文本
+            entities: 已识别的实体列表
+            
+        Returns:
+            关系列表
+        """
+        try:
+            entity_names = [e["name"] for e in entities]
+            result = self.relation_chain.invoke({
+                "text": text[:2000],
+                "entities": ", ".join(entity_names)
+            })
+            relations = result.get("relations", [])
+            print(f"✅ 提取到 {len(relations)} 个关系")
+            return relations
+        except Exception as e:
+            print(f"❌ 关系提取失败: {e}")
+            return []
+    
+    def extract_from_document(self, document_text: str) -> Dict:
+        """
+        从单个文档中提取实体和关系
+        
+        Args:
+            document_text: 文档文本
+            
+        Returns:
+            包含实体和关系的字典
+        """
+        print("🔍 开始提取实体...")
+        entities = self.extract_entities(document_text)
+        
+        print("🔍 开始提取关系...")
+        relations = self.extract_relations(document_text, entities)
+        
+        return {
+            "entities": entities,
+            "relations": relations
+        }
+
+
+class EntityDeduplicator:
+    """实体去重和合并"""
+    
+    def __init__(self):
+        self.llm = ChatOllama(model=LOCAL_LLM, format="json", temperature=0)
+        
+        self.merge_prompt = PromptTemplate(
+            template="""判断以下两个实体是否指向同一个对象:
+
+实体1: {entity1_name} - {entity1_desc}
+实体2: {entity2_name} - {entity2_desc}
+
+如果是同一个对象，返回:
+{{
+    "is_same": true,
+    "canonical_name": "标准名称",
+    "reason": "原因"
+}}
+
+如果不是，返回:
+{{
+    "is_same": false,
+    "reason": "原因"
+}}
+
+只返回JSON，不要其他内容。
+""",
+            input_variables=["entity1_name", "entity1_desc", "entity2_name", "entity2_desc"]
+        )
+        
+        self.merge_chain = self.merge_prompt | self.llm | JsonOutputParser()
+    
+    def deduplicate_entities(self, entities: List[Dict]) -> Dict:
+        """
+        去重实体列表
+        
+        Args:
+            entities: 实体列表
+            
+        Returns:
+            包含entities和mapping的字典
+        """
+        if len(entities) <= 1:
+            # 返回字典格式，保持一致性
+            entity_mapping = {entity["name"]: entity["name"] for entity in entities} if entities else {}
+            return {
+                "entities": entities,
+                "mapping": entity_mapping
+            }
+        
+        print(f"🔄 开始去重 {len(entities)} 个实体...")
+        
+        # 简单的基于名称的去重
+        unique_entities = {}
+        entity_mapping = {}  # 映射别名到标准名称
+        
+        for entity in entities:
+            name = entity["name"].lower().strip()
+            
+            # 查找是否有相似实体
+            merged = False
+            for canonical_name, canonical_entity in unique_entities.items():
+                # 简单的字符串匹配（可以用LLM做更智能的判断）
+                if name in canonical_name or canonical_name in name:
+                    entity_mapping[entity["name"]] = canonical_name
+                    merged = True
+                    break
+            
+            if not merged:
+                unique_entities[name] = entity
+                entity_mapping[entity["name"]] = name
+        
+        print(f"✅ 去重完成，剩余 {len(unique_entities)} 个唯一实体")
+        
+        return {
+            "entities": list(unique_entities.values()),
+            "mapping": entity_mapping
+        }
+
+
+def initialize_entity_extractor():
+    """初始化实体提取器"""
+    return EntityExtractor()

graph_indexer.py

@@ -0,0 +1,145 @@
+"""
+GraphRAG索引器
+负责构建层次化的知识图谱索引，包括实体提取、图谱构建、社区检测和摘要生成
+"""
+
+from typing import List, Dict
+from langchain.schema import Document
+
+from entity_extractor import EntityExtractor, EntityDeduplicator
+from knowledge_graph import KnowledgeGraph, CommunitySummarizer
+
+
+class GraphRAGIndexer:
+    """GraphRAG索引器 - 实现Microsoft GraphRAG的索引流程"""
+    
+    def __init__(self):
+        print("🚀 初始化GraphRAG索引器...")
+        
+        self.entity_extractor = EntityExtractor()
+        self.entity_deduplicator = EntityDeduplicator()
+        self.knowledge_graph = KnowledgeGraph()
+        self.community_summarizer = CommunitySummarizer()
+        
+        self.indexed = False
+        
+        print("✅ GraphRAG索引器初始化完成")
+    
+    def index_documents(self, documents: List[Document], 
+                       batch_size: int = 10,
+                       save_path: str = None) -> KnowledgeGraph:
+        """
+        对文档集合建立GraphRAG索引
+        
+        工作流程（遵循Microsoft GraphRAG）:
+        1. 文档分块（已在document_processor中完成）
+        2. 实体和关系提取
+        3. 实体去重和合并
+        4. 构建知识图谱
+        5. 社区检测
+        6. 生成社区摘要
+        
+        Args:
+            documents: 文档列表
+            batch_size: 批处理大小
+            save_path: 保存路径
+            
+        Returns:
+            构建好的知识图谱
+        """
+        print(f"\n{'='*50}")
+        print(f"📊 开始GraphRAG索引流程")
+        print(f"   文档数量: {len(documents)}")
+        print(f"{'='*50}\n")
+        
+        # 步骤1: 实体和关系提取
+        print("📍 步骤 1/5: 实体和关系提取")
+        extraction_results = []
+        
+        for i in range(0, len(documents), batch_size):
+            batch = documents[i:i+batch_size]
+            print(f"   处理批次 {i//batch_size + 1}/{(len(documents)-1)//batch_size + 1}...")
+            
+            for doc in batch:
+                result = self.entity_extractor.extract_from_document(doc.page_content)
+                extraction_results.append(result)
+        
+        # 步骤2: 实体去重
+        print("\n📍 步骤 2/5: 实体去重和合并")
+        all_entities = []
+        all_relations = []
+        
+        for result in extraction_results:
+            all_entities.extend(result.get("entities", []))
+            all_relations.extend(result.get("relations", []))
+        
+        dedup_result = self.entity_deduplicator.deduplicate_entities(all_entities)
+        unique_entities = dedup_result["entities"]
+        entity_mapping = dedup_result["mapping"]
+        
+        # 更新关系中的实体名称
+        mapped_relations = []
+        for relation in all_relations:
+            source = entity_mapping.get(relation["source"], relation["source"])
+            target = entity_mapping.get(relation["target"], relation["target"])
+            mapped_relations.append({
+                **relation,
+                "source": source,
+                "target": target
+            })
+        
+        # 步骤3: 构建知识图谱
+        print("\n📍 步骤 3/5: 构建知识图谱")
+        cleaned_results = [{
+            "entities": unique_entities,
+            "relations": mapped_relations
+        }]
+        self.knowledge_graph.build_from_extractions(cleaned_results)
+        
+        # 步骤4: 社区检测
+        print("\n📍 步骤 4/5: 社区检测")
+        self.knowledge_graph.detect_communities(algorithm="louvain")
+        
+        # 步骤5: 生成社区摘要
+        print("\n📍 步骤 5/5: 生成社区摘要")
+        self.community_summarizer.summarize_all_communities(self.knowledge_graph)
+        
+        # 保存图谱
+        if save_path:
+            self.knowledge_graph.save_to_file(save_path)
+        
+        self.indexed = True
+        
+        # 打印统计信息
+        print(f"\n{'='*50}")
+        print("✅ GraphRAG索引构建完成!")
+        stats = self.knowledge_graph.get_statistics()
+        print(f"\n📊 统计信息:")
+        print(f"   - 节点数: {stats['num_nodes']}")
+        print(f"   - 边数: {stats['num_edges']}")
+        print(f"   - 社区数: {stats['num_communities']}")
+        print(f"   - 图密度: {stats['density']:.4f}")
+        print(f"\n   实体类型分布:")
+        for etype, count in stats['entity_types'].items():
+            print(f"     • {etype}: {count}")
+        print(f"{'='*50}\n")
+        
+        return self.knowledge_graph
+    
+    def get_graph(self) -> KnowledgeGraph:
+        """获取知识图谱"""
+        if not self.indexed:
+            print("⚠️ 图谱尚未构建，请先调用 index_documents()")
+        return self.knowledge_graph
+    
+    def load_index(self, filepath: str) -> KnowledgeGraph:
+        """加载已有的图谱索引"""
+        print(f"📂 从文件加载图谱索引: {filepath}")
+        self.knowledge_graph.load_from_file(filepath)
+        self.indexed = True
+        return self.knowledge_graph
+
+
+def initialize_graph_indexer():
+    """初始化GraphRAG索引器"""
+    return GraphRAGIndexer()

graph_retriever.py

@@ -0,0 +1,275 @@
+"""
+GraphRAG检索器
+实现基于知识图谱的检索策略，包括本地查询和全局查询
+"""
+
+from typing import List, Dict, Set, Tuple
+from langchain.prompts import PromptTemplate
+from langchain_community.chat_models import ChatOllama
+from langchain_core.output_parsers import StrOutputParser, JsonOutputParser
+
+from knowledge_graph import KnowledgeGraph
+from config import LOCAL_LLM
+
+
+class GraphRetriever:
+    """基于知识图谱的检索器"""
+    
+    def __init__(self, knowledge_graph: KnowledgeGraph):
+        self.kg = knowledge_graph
+        self.llm = ChatOllama(model=LOCAL_LLM, temperature=0.3)
+        
+        # 实体识别提示
+        self.entity_recognition_prompt = PromptTemplate(
+            template="""从以下问题中识别关键实体和概念:
+
+问题: {question}
+
+已知实体示例: {sample_entities}
+
+请识别问题中提到的实体，返回JSON格式:
+{{
+    "entities": ["实体1", "实体2", ...]
+}}
+
+只返回JSON，不要其他内容。
+""",
+            input_variables=["question", "sample_entities"]
+        )
+        
+        # 全局查询生成提示
+        self.global_query_prompt = PromptTemplate(
+            template="""你是一个知识图谱分析专家。基于以下社区摘要，回答用户问题。
+
+用户问题: {question}
+
+相关社区摘要:
+{community_summaries}
+
+请基于这些摘要提供一个综合性的答案。如果摘要中没有相关信息，请说明。
+
+答案:
+""",
+            input_variables=["question", "community_summaries"]
+        )
+        
+        # 本地查询生成提示
+        self.local_query_prompt = PromptTemplate(
+            template="""基于以下实体及其关系信息，回答用户问题。
+
+用户问题: {question}
+
+相关实体信息:
+{entity_info}
+
+实体间的关系:
+{relations}
+
+请基于这些信息提供答案。
+
+答案:
+""",
+            input_variables=["question", "entity_info", "relations"]
+        )
+        
+        self.entity_recognition_chain = self.entity_recognition_prompt | self.llm | JsonOutputParser()
+        self.global_query_chain = self.global_query_prompt | self.llm | StrOutputParser()
+        self.local_query_chain = self.local_query_prompt | self.llm | StrOutputParser()
+    
+    def recognize_entities(self, question: str) -> List[str]:
+        """
+        从问题中识别实体
+        
+        Args:
+            question: 用户问题
+            
+        Returns:
+            识别到的实体列表
+        """
+        # 获取一些示例实体
+        sample_entities = list(self.kg.entities.keys())[:10]
+        sample_text = ", ".join(sample_entities)
+        
+        try:
+            result = self.entity_recognition_chain.invoke({
+                "question": question,
+                "sample_entities": sample_text
+            })
+            entities = result.get("entities", [])
+            
+            # 匹配到图谱中的实体
+            matched_entities = []
+            for entity in entities:
+                # 精确匹配
+                if entity in self.kg.entities:
+                    matched_entities.append(entity)
+                else:
+                    # 模糊匹配
+                    for kg_entity in self.kg.entities.keys():
+                        if entity.lower() in kg_entity.lower() or kg_entity.lower() in entity.lower():
+                            matched_entities.append(kg_entity)
+                            break
+            
+            print(f"🔍 识别到实体: {matched_entities}")
+            return matched_entities
+            
+        except Exception as e:
+            print(f"❌ 实体识别失败: {e}")
+            return []
+    
+    def local_query(self, question: str, max_hops: int = 2, top_k: int = 10) -> str:
+        """
+        本地查询 - 基于问题中的实体及其邻域进行检索
+        
+        适用场景: 针对特定实体的详细问题
+        例如: "AlphaCodium的作者是谁？"
+        
+        Args:
+            question: 用户问题
+            max_hops: 最大跳数
+            top_k: 返回的最大实体数
+            
+        Returns:
+            答案文本
+        """
+        print(f"\n🔎 执行本地查询...")
+        
+        # 1. 识别问题中的实体
+        mentioned_entities = self.recognize_entities(question)
+        
+        if not mentioned_entities:
+            return "未能在知识图谱中找到相关实体。"
+        
+        # 2. 获取实体的邻域
+        relevant_entities = set()
+        for entity in mentioned_entities:
+            neighbors = self.kg.get_node_neighbors(entity, depth=max_hops)
+            relevant_entities.update(neighbors)
+        
+        relevant_entities = list(relevant_entities)[:top_k]
+        
+        # 3. 收集实体信息
+        entity_info_list = []
+        for entity in relevant_entities:
+            info = self.kg.get_entity_info(entity)
+            if info:
+                entity_info_list.append(
+                    f"- {info['name']} ({info.get('type', 'UNKNOWN')}): {info.get('description', '无描述')}"
+                )
+        
+        # 4. 收集关系信息
+        relation_list = []
+        for u, v, data in self.kg.graph.edges(data=True):
+            if u in relevant_entities and v in relevant_entities:
+                relation_list.append(
+                    f"- {u} --[{data.get('relation_type', 'RELATED')}]--> {v}: {data.get('description', '')}"
+                )
+        
+        entity_info_text = "\n".join(entity_info_list) if entity_info_list else "无相关实体信息"
+        relations_text = "\n".join(relation_list[:20]) if relation_list else "无相关关系"
+        
+        # 5. 生成答案
+        try:
+            answer = self.local_query_chain.invoke({
+                "question": question,
+                "entity_info": entity_info_text,
+                "relations": relations_text
+            })
+            print(f"✅ 本地查询完成")
+            return answer.strip()
+        except Exception as e:
+            print(f"❌ 本地查询失败: {e}")
+            return "查询失败，请重试。"
+    
+    def global_query(self, question: str, top_k_communities: int = 5) -> str:
+        """
+        全局查询 - 基于社区摘要进行高层次查询
+        
+        适用场景: 需要整体理解的概括性问题
+        例如: "这些文档主要讨论什么主题？"
+        
+        Args:
+            question: 用户问题
+            top_k_communities: 使用的社区数量
+            
+        Returns:
+            答案文本
+        """
+        print(f"\n🌍 执行全局查询...")
+        
+        if not self.kg.community_summaries:
+            return "知识图谱尚未生成社区摘要，请先运行索引流程。"
+        
+        # 获取社区摘要
+        community_summaries = []
+        for cid, summary in list(self.kg.community_summaries.items())[:top_k_communities]:
+            community_summaries.append(f"社区 {cid}:\n{summary}\n")
+        
+        summaries_text = "\n".join(community_summaries)
+        
+        # 生成答案
+        try:
+            answer = self.global_query_chain.invoke({
+                "question": question,
+                "community_summaries": summaries_text
+            })
+            print(f"✅ 全局查询完成")
+            return answer.strip()
+        except Exception as e:
+            print(f"❌ 全局查询失败: {e}")
+            return "查询失败，请重试。"
+    
+    def hybrid_query(self, question: str) -> Dict[str, str]:
+        """
+        混合查询 - 同时执行本地和全局查询，返回两种结果
+        
+        Args:
+            question: 用户问题
+            
+        Returns:
+            包含本地和全局查询结果的字典
+        """
+        print(f"\n🔀 执行混合查询...")
+        
+        local_answer = self.local_query(question)
+        global_answer = self.global_query(question)
+        
+        return {
+            "local": local_answer,
+            "global": global_answer,
+            "question": question
+        }
+    
+    def smart_query(self, question: str) -> str:
+        """
+        智能查询 - 根据问题类型自动选择查询策略
+        
+        Args:
+            question: 用户问题
+            
+        Returns:
+            答案文本
+        """
+        # 判断问题类型
+        question_lower = question.lower()
+        
+        # 包含具体实体名称的问题 -> 本地查询
+        mentioned_entities = self.recognize_entities(question)
+        if mentioned_entities:
+            print("📍 检测到具体实体，使用本地查询")
+            return self.local_query(question)
+        
+        # 概括性问题 -> 全局查询
+        global_keywords = ["主要", "总体", "概述", "整体", "主题", "讨论", "内容", "what", "overview", "main", "topics"]
+        if any(keyword in question_lower for keyword in global_keywords):
+            print("🌐 检测到概括性问题，使用全局查询")
+            return self.global_query(question)
+        
+        # 默认使用本地查询
+        print("📍 使用本地查询作为默认策略")
+        return self.local_query(question)
+
+
+def initialize_graph_retriever(knowledge_graph: KnowledgeGraph):
+    """初始化GraphRAG检索器"""
+    return GraphRetriever(knowledge_graph)

knowledge_graph.py

@@ -0,0 +1,347 @@
+"""
+知识图谱模块
+实现GraphRAG的核心功能：图谱构建、社区检测、层次化摘要
+"""
+
+import networkx as nx
+from typing import List, Dict, Set, Tuple, Optional
+from collections import defaultdict
+import json
+
+try:
+    from community import community_louvain  # python-louvain
+    LOUVAIN_AVAILABLE = True
+except ImportError:
+    LOUVAIN_AVAILABLE = False
+    print("⚠️ python-louvain未安装，社区检测功能受限")
+
+from langchain.prompts import PromptTemplate
+from langchain_community.chat_models import ChatOllama
+from langchain_core.output_parsers import StrOutputParser
+from config import LOCAL_LLM
+
+
+class KnowledgeGraph:
+    """知识图谱类 - 使用NetworkX构建和管理图谱"""
+    
+    def __init__(self):
+        self.graph = nx.Graph()  # 无向图
+        self.entities = {}  # 实体详细信息
+        self.communities = {}  # 社区划分结果
+        self.community_summaries = {}  # 社区摘要
+        
+    def add_entity(self, name: str, entity_type: str, description: str = "", **kwargs):
+        """添加实体节点"""
+        self.graph.add_node(
+            name,
+            type=entity_type,
+            description=description,
+            **kwargs
+        )
+        self.entities[name] = {
+            "name": name,
+            "type": entity_type,
+            "description": description,
+            **kwargs
+        }
+    
+    def add_relation(self, source: str, target: str, relation_type: str, 
+                    description: str = "", weight: float = 1.0):
+        """添加关系边"""
+        self.graph.add_edge(
+            source,
+            target,
+            relation_type=relation_type,
+            description=description,
+            weight=weight
+        )
+    
+    def build_from_extractions(self, extraction_results: List[Dict]):
+        """
+        从实体提取结果构建图谱
+        
+        Args:
+            extraction_results: 实体和关系提取结果列表
+        """
+        print("🔨 开始构建知识图谱...")
+        
+        total_entities = 0
+        total_relations = 0
+        
+        for result in extraction_results:
+            # 添加实体
+            entities = result.get("entities", [])
+            for entity in entities:
+                self.add_entity(
+                    name=entity["name"],
+                    entity_type=entity.get("type", "UNKNOWN"),
+                    description=entity.get("description", "")
+                )
+                total_entities += 1
+            
+            # 添加关系
+            relations = result.get("relations", [])
+            for relation in relations:
+                source = relation.get("source")
+                target = relation.get("target")
+                
+                # 确保节点存在
+                if source in self.graph and target in self.graph:
+                    self.add_relation(
+                        source=source,
+                        target=target,
+                        relation_type=relation.get("relation_type", "RELATED_TO"),
+                        description=relation.get("description", "")
+                    )
+                    total_relations += 1
+        
+        print(f"✅ 图谱构建完成: {total_entities} 个实体, {total_relations} 个关系")
+        print(f"   实际节点数: {self.graph.number_of_nodes()}")
+        print(f"   实际边数: {self.graph.number_of_edges()}")
+    
+    def detect_communities(self, algorithm: str = "louvain") -> Dict[str, int]:
+        """
+        社区检测 - GraphRAG的核心组件
+        
+        Args:
+            algorithm: 社区检测算法 ('louvain', 'greedy', 'label_propagation')
+            
+        Returns:
+            节点到社区ID的映射
+        """
+        print(f"🔍 开始社区检测 (算法: {algorithm})...")
+        
+        if self.graph.number_of_nodes() == 0:
+            print("⚠️ 图谱为空，跳过社区检测")
+            return {}
+        
+        try:
+            if algorithm == "louvain" and LOUVAIN_AVAILABLE:
+                communities = community_louvain.best_partition(self.graph)
+            elif algorithm == "greedy":
+                communities_generator = nx.community.greedy_modularity_communities(self.graph)
+                communities = {}
+                for idx, community_set in enumerate(communities_generator):
+                    for node in community_set:
+                        communities[node] = idx
+            elif algorithm == "label_propagation":
+                communities_generator = nx.community.label_propagation_communities(self.graph)
+                communities = {}
+                for idx, community_set in enumerate(communities_generator):
+                    for node in community_set:
+                        communities[node] = idx
+            else:
+                print(f"⚠️ 未知算法 {algorithm}，使用贪婪算法")
+                communities_generator = nx.community.greedy_modularity_communities(self.graph)
+                communities = {}
+                for idx, community_set in enumerate(communities_generator):
+                    for node in community_set:
+                        communities[node] = idx
+            
+            self.communities = communities
+            num_communities = len(set(communities.values()))
+            print(f"✅ 检测到 {num_communities} 个社区")
+            
+            return communities
+            
+        except Exception as e:
+            print(f"❌ 社区检测失败: {e}")
+            return {}
+    
+    def get_community_members(self, community_id: int) -> List[str]:
+        """获取指定社区的所有成员"""
+        return [node for node, cid in self.communities.items() if cid == community_id]
+    
+    def get_community_subgraph(self, community_id: int) -> nx.Graph:
+        """获取指定社区的子图"""
+        members = self.get_community_members(community_id)
+        return self.graph.subgraph(members)
+    
+    def get_node_neighbors(self, node: str, depth: int = 1) -> Set[str]:
+        """获取节点的邻居（支持多跳）"""
+        if node not in self.graph:
+            return set()
+        
+        neighbors = {node}
+        current_layer = {node}
+        
+        for _ in range(depth):
+            next_layer = set()
+            for n in current_layer:
+                next_layer.update(self.graph.neighbors(n))
+            neighbors.update(next_layer)
+            current_layer = next_layer
+        
+        return neighbors
+    
+    def get_entity_info(self, entity_name: str) -> Optional[Dict]:
+        """获取实体详细信息"""
+        return self.entities.get(entity_name)
+    
+    def search_entities_by_type(self, entity_type: str) -> List[str]:
+        """按类型搜索实体"""
+        return [
+            name for name, data in self.entities.items()
+            if data.get("type") == entity_type
+        ]
+    
+    def get_statistics(self) -> Dict:
+        """获取图谱统计信息"""
+        stats = {
+            "num_nodes": self.graph.number_of_nodes(),
+            "num_edges": self.graph.number_of_edges(),
+            "num_communities": len(set(self.communities.values())) if self.communities else 0,
+            "density": nx.density(self.graph) if self.graph.number_of_nodes() > 0 else 0,
+            "entity_types": {}
+        }
+        
+        # 统计实体类型分布
+        for entity in self.entities.values():
+            etype = entity.get("type", "UNKNOWN")
+            stats["entity_types"][etype] = stats["entity_types"].get(etype, 0) + 1
+        
+        return stats
+    
+    def save_to_file(self, filepath: str):
+        """保存图谱到文件"""
+        data = {
+            "entities": self.entities,
+            "edges": [
+                {
+                    "source": u,
+                    "target": v,
+                    "data": data
+                }
+                for u, v, data in self.graph.edges(data=True)
+            ],
+            "communities": self.communities,
+            "community_summaries": self.community_summaries
+        }
+        
+        with open(filepath, 'w', encoding='utf-8') as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+        
+        print(f"✅ 图谱已保存到: {filepath}")
+    
+    def load_from_file(self, filepath: str):
+        """从文件加载图谱"""
+        with open(filepath, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        self.entities = data.get("entities", {})
+        self.communities = data.get("communities", {})
+        self.community_summaries = data.get("community_summaries", {})
+        
+        # 重建图
+        self.graph.clear()
+        for name, entity in self.entities.items():
+            self.add_entity(**entity)
+        
+        for edge in data.get("edges", []):
+            self.graph.add_edge(
+                edge["source"],
+                edge["target"],
+                **edge["data"]
+            )
+        
+        print(f"✅ 图谱已从文件加载: {filepath}")
+
+
+class CommunitySummarizer:
+    """社区摘要生成器 - GraphRAG的关键组件"""
+    
+    def __init__(self):
+        self.llm = ChatOllama(model=LOCAL_LLM, temperature=0.3)
+        
+        self.summary_prompt = PromptTemplate(
+            template="""你是一个知识图谱分析专家。请为以下社区生成一个综合摘要。
+
+社区成员（实体）:
+{entities}
+
+实体间的关系:
+{relations}
+
+请生成一个简洁的摘要，描述：
+1. 这个社区的主题是什么
+2. 主要包含哪些核心概念
+3. 实体之间的关键关系
+
+摘要（2-3句话）:
+""",
+            input_variables=["entities", "relations"]
+        )
+        
+        self.summary_chain = self.summary_prompt | self.llm | StrOutputParser()
+    
+    def summarize_community(self, kg: KnowledgeGraph, community_id: int) -> str:
+        """
+        为指定社区生成摘要
+        
+        Args:
+            kg: 知识图谱对象
+            community_id: 社区ID
+            
+        Returns:
+            社区摘要文本
+        """
+        members = kg.get_community_members(community_id)
+        subgraph = kg.get_community_subgraph(community_id)
+        
+        # 准备实体信息
+        entity_info = []
+        for member in members[:20]:  # 限制数量
+            info = kg.get_entity_info(member)
+            if info:
+                entity_info.append(
+                    f"- {info['name']} ({info.get('type', 'UNKNOWN')}): {info.get('description', '无描述')}"
+                )
+        
+        # 准备关系信息
+        relation_info = []
+        for u, v, data in subgraph.edges(data=True):
+            relation_info.append(
+                f"- {u} --[{data.get('relation_type', 'RELATED')}]--> {v}"
+            )
+        
+        entities_text = "\n".join(entity_info) if entity_info else "无实体"
+        relations_text = "\n".join(relation_info[:15]) if relation_info else "无关系"
+        
+        try:
+            summary = self.summary_chain.invoke({
+                "entities": entities_text,
+                "relations": relations_text
+            })
+            return summary.strip()
+        except Exception as e:
+            print(f"❌ 社区 {community_id} 摘要生成失败: {e}")
+            return f"社区{community_id}: 包含{len(members)}个实体"
+    
+    def summarize_all_communities(self, kg: KnowledgeGraph) -> Dict[int, str]:
+        """为所有社区生成摘要"""
+        if not kg.communities:
+            print("⚠️ 未检测到社区，请先运行社区检测")
+            return {}
+        
+        community_ids = set(kg.communities.values())
+        print(f"📝 开始为 {len(community_ids)} 个社区生成摘要...")
+        
+        summaries = {}
+        for cid in community_ids:
+            print(f"   处理社区 {cid}...")
+            summary = self.summarize_community(kg, cid)
+            summaries[cid] = summary
+            kg.community_summaries[cid] = summary
+        
+        print("✅ 所有社区摘要生成完成")
+        return summaries
+
+
+def initialize_knowledge_graph():
+    """初始化知识图谱"""
+    return KnowledgeGraph()
+
+
+def initialize_community_summarizer():
+    """初始化社区摘要生成器"""
+    return CommunitySummarizer()

local_llm_rag.py

@@ -0,0 +1,428 @@
+
+
+"""
+源文件：local_llm_rag.py
+This is a simple example of how to use LangChain to build a local LLM RAG system.
+"""
+import getpass
+import os
+
+
+def _set_env(var: str):
+    if not os.environ.get(var):
+        os.environ[var] = getpass.getpass(f"{var}: ")
+
+
+_set_env("TAVILY_API_KEY")
+_set_env("NOMIC_API_KEY")
+
+# Ollama model name
+local_llm = "mistral"
+
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.document_loaders import WebBaseLoader
+from langchain_community.vectorstores import Chroma
+from langchain_nomic.embeddings import NomicEmbeddings
+
+urls = [
+    "https://lilianweng.github.io/posts/2023-06-23-agent/",
+    "https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/",
+    "https://lilianweng.github.io/posts/2023-10-25-adv-attack-llm/",
+]
+
+docs = [WebBaseLoader(url).load() for url in urls]
+docs_list = [item for sublist in docs for item in sublist]
+
+text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(
+    chunk_size=250, chunk_overlap=0
+)
+doc_splits = text_splitter.split_documents(docs_list)
+
+# Add to vectorDB
+vectorstore = Chroma.from_documents(
+    documents=doc_splits,
+    collection_name="rag-chroma",
+    embedding=NomicEmbeddings(model="nomic-embed-text-v1.5", inference_mode="local"),
+)
+retriever = vectorstore.as_retriever()
+
+### Router
+
+from langchain.prompts import PromptTemplate
+from langchain_community.chat_models import ChatOllama
+from langchain_core.output_parsers import JsonOutputParser
+
+# LLM
+llm = ChatOllama(model=local_llm, format="json", temperature=0)
+
+prompt = PromptTemplate(
+    template="""You are an expert at routing a user question to a vectorstore or web search. \n
+    Use the vectorstore for questions on LLM  agents, prompt engineering, and adversarial attacks. \n
+    You do not need to be stringent with the keywords in the question related to these topics. \n
+    Otherwise, use web-search. Give a binary choice 'web_search' or 'vectorstore' based on the question. \n
+    Return the a JSON with a single key 'datasource' and no premable or explanation. \n
+    Question to route: {question}""",
+    input_variables=["question"],
+)
+
+question_router = prompt | llm | JsonOutputParser()
+question = "llm agent memory"
+docs = retriever.get_relevant_documents(question)
+doc_txt = docs[1].page_content
+print(question_router.invoke({"question": question}))
+
+
+### Generate
+
+from langchain import hub
+from langchain_community.chat_models import ChatOllama
+from langchain_core.output_parsers import StrOutputParser
+
+# Prompt
+prompt = hub.pull("rlm/rag-prompt")
+
+# LLM
+llm = ChatOllama(model=local_llm, temperature=0)
+
+
+# Post-processing
+def format_docs(docs):
+    return "\n\n".join(doc.page_content for doc in docs)
+
+
+# Chain
+rag_chain = prompt | llm | StrOutputParser()
+
+# Run
+question = "agent memory"
+generation = rag_chain.invoke({"context": docs, "question": question})
+print(generation)
+
+### Answer Grader
+
+# LLM
+llm = ChatOllama(model=local_llm, format="json", temperature=0)
+
+# Prompt
+prompt = PromptTemplate(
+    template="""You are a grader assessing whether an answer is useful to resolve a question. \n 
+    Here is the answer:
+    \n ------- \n
+    {generation} 
+    \n ------- \n
+    Here is the question: {question}
+    Give a binary score 'yes' or 'no' to indicate whether the answer is useful to resolve a question. \n
+    Provide the binary score as a JSON with a single key 'score' and no preamble or explanation.""",
+    input_variables=["generation", "question"],
+)
+
+answer_grader = prompt | llm | JsonOutputParser()
+answer_grader.invoke({"question": question, "generation": generation})
+
+### Question Re-writer
+
+# LLM
+llm = ChatOllama(model=local_llm, temperature=0)
+
+# Prompt
+re_write_prompt = PromptTemplate(
+    template="""You a question re-writer that converts an input question to a better version that is optimized \n 
+     for vectorstore retrieval. Look at the initial and formulate an improved question. \n
+     Here is the initial question: \n\n {question}. Improved question with no preamble: \n """,
+    input_variables=["generation", "question"],
+)
+
+question_rewriter = re_write_prompt | llm | StrOutputParser()
+question_rewriter.invoke({"question": question})
+
+
+### Search
+
+from langchain_community.tools.tavily_search import TavilySearchResults
+
+web_search_tool = TavilySearchResults(k=3)
+
+from typing import List
+
+from typing_extensions import TypedDict
+
+
+class GraphState(TypedDict):
+    """
+    Represents the state of our graph.
+
+    Attributes:
+        question: question
+        generation: LLM generation
+        documents: list of documents
+    """
+
+    question: str
+    generation: str
+    documents: List[str]
+
+    from langchain.schema import Document
+
+
+def retrieve(state):
+    """
+    Retrieve documents
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        state (dict): New key added to state, documents, that contains retrieved documents
+    """
+    print("---RETRIEVE---")
+    question = state["question"]
+
+    # Retrieval
+    documents = retriever.get_relevant_documents(question)
+    return {"documents": documents, "question": question}
+
+
+def generate(state):
+    """
+    Generate answer
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        state (dict): New key added to state, generation, that contains LLM generation
+    """
+    print("---GENERATE---")
+    question = state["question"]
+    documents = state["documents"]
+
+    # RAG generation
+    generation = rag_chain.invoke({"context": documents, "question": question})
+    return {"documents": documents, "question": question, "generation": generation}
+
+
+def grade_documents(state):
+    """
+    Determines whether the retrieved documents are relevant to the question.
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        state (dict): Updates documents key with only filtered relevant documents
+    """
+
+    print("---CHECK DOCUMENT RELEVANCE TO QUESTION---")
+    question = state["question"]
+    documents = state["documents"]
+
+    # Score each doc
+    filtered_docs = []
+    for d in documents:
+        score = retrieval_grader.invoke(
+            {"question": question, "document": d.page_content}
+        )
+        grade = score["score"]
+        if grade == "yes":
+            print("---GRADE: DOCUMENT RELEVANT---")
+            filtered_docs.append(d)
+        else:
+            print("---GRADE: DOCUMENT NOT RELEVANT---")
+            continue
+    return {"documents": filtered_docs, "question": question}
+
+
+def transform_query(state):
+    """
+    Transform the query to produce a better question.
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        state (dict): Updates question key with a re-phrased question
+    """
+
+    print("---TRANSFORM QUERY---")
+    question = state["question"]
+    documents = state["documents"]
+
+    # Re-write question
+    better_question = question_rewriter.invoke({"question": question})
+    return {"documents": documents, "question": better_question}
+
+
+def web_search(state):
+    """
+    Web search based on the re-phrased question.
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        state (dict): Updates documents key with appended web results
+    """
+
+    print("---WEB SEARCH---")
+    question = state["question"]
+
+    # Web search
+    docs = web_search_tool.invoke({"query": question})
+    web_results = "\n".join([d["content"] for d in docs])
+    web_results = Document(page_content=web_results)
+
+    return {"documents": web_results, "question": question}
+
+
+### Edges ###
+
+
+def route_question(state):
+    """
+    Route question to web search or RAG.
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        str: Next node to call
+    """
+
+    print("---ROUTE QUESTION---")
+    question = state["question"]
+    print(question)
+    source = question_router.invoke({"question": question})
+    print(source)
+    print(source["datasource"])
+    if source["datasource"] == "web_search":
+        print("---ROUTE QUESTION TO WEB SEARCH---")
+        return "web_search"
+    elif source["datasource"] == "vectorstore":
+        print("---ROUTE QUESTION TO RAG---")
+        return "vectorstore"
+
+
+def decide_to_generate(state):
+    """
+    Determines whether to generate an answer, or re-generate a question.
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        str: Binary decision for next node to call
+    """
+
+    print("---ASSESS GRADED DOCUMENTS---")
+    state["question"]
+    filtered_documents = state["documents"]
+
+    if not filtered_documents:
+        # All documents have been filtered check_relevance
+        # We will re-generate a new query
+        print(
+            "---DECISION: ALL DOCUMENTS ARE NOT RELEVANT TO QUESTION, TRANSFORM QUERY---"
+        )
+        return "transform_query"
+    else:
+        # We have relevant documents, so generate answer
+        print("---DECISION: GENERATE---")
+        return "generate"
+
+
+def grade_generation_v_documents_and_question(state):
+    """
+    Determines whether the generation is grounded in the document and answers question.
+
+    Args:
+        state (dict): The current graph state
+
+    Returns:
+        str: Decision for next node to call
+    """
+
+    print("---CHECK HALLUCINATIONS---")
+    question = state["question"]
+    documents = state["documents"]
+    generation = state["generation"]
+
+    score = hallucination_grader.invoke(
+        {"documents": documents, "generation": generation}
+    )
+    grade = score["score"]
+
+    # Check hallucination
+    if grade == "yes":
+        print("---DECISION: GENERATION IS GROUNDED IN DOCUMENTS---")
+        # Check question-answering
+        print("---GRADE GENERATION vs QUESTION---")
+        score = answer_grader.invoke({"question": question, "generation": generation})
+        grade = score["score"]
+        if grade == "yes":
+            print("---DECISION: GENERATION ADDRESSES QUESTION---")
+            return "useful"
+        else:
+            print("---DECISION: GENERATION DOES NOT ADDRESS QUESTION---")
+            return "not useful"
+    else:
+        pprint("---DECISION: GENERATION IS NOT GROUNDED IN DOCUMENTS, RE-TRY---")
+        return "not supported"
+    
+    from langgraph.graph import END, StateGraph, START
+
+workflow = StateGraph(GraphState)
+
+# Define the nodes
+workflow.add_node("web_search", web_search)  # web search
+workflow.add_node("retrieve", retrieve)  # retrieve
+workflow.add_node("grade_documents", grade_documents)  # grade documents
+workflow.add_node("generate", generate)  # generate
+workflow.add_node("transform_query", transform_query)  # transform_query
+
+# Build graph
+workflow.add_conditional_edges(
+    START,
+    route_question,
+    {
+        "web_search": "web_search",
+        "vectorstore": "retrieve",
+    },
+)
+workflow.add_edge("web_search", "generate")
+workflow.add_edge("retrieve", "grade_documents")
+workflow.add_conditional_edges(
+    "grade_documents",
+    decide_to_generate,
+    {
+        "transform_query": "transform_query",
+        "generate": "generate",
+    },
+)
+workflow.add_edge("transform_query", "retrieve")
+workflow.add_conditional_edges(
+    "generate",
+    grade_generation_v_documents_and_question,
+    {
+        "not supported": "generate",
+        "useful": END,
+        "not useful": "transform_query",
+    },
+)
+
+# Compile
+app = workflow.compile()
+
+from pprint import pprint
+
+# Run
+inputs = {"question": "What is the AlphaCodium paper about?"}
+for output in app.stream(inputs):
+    for key, value in output.items():
+        # Node
+        pprint(f"Node '{key}':")
+        # Optional: print full state at each node
+        # pprint.pprint(value["keys"], indent=2, width=80, depth=None)
+    pprint("\n---\n")
+
+# Final generation
+pprint(value["generation"])

main.py

@@ -0,0 +1,174 @@
+"""
+主应用程序入口
+集成所有模块，构建工作流并运行自适应RAG系统
+"""
+
+from langgraph.graph import END, StateGraph, START
+from pprint import pprint
+
+from config import setup_environment
+from document_processor import initialize_document_processor
+from routers_and_graders import initialize_graders_and_router
+from workflow_nodes import WorkflowNodes, GraphState
+
+
+class AdaptiveRAGSystem:
+    """自适应RAG系统主类"""
+    
+    def __init__(self):
+        print("初始化自适应RAG系统...")
+        
+        # 设置环境和验证API密钥
+        try:
+            setup_environment()
+       
+            print("✅ API密钥验证成功")
+        except ValueError as e:
+            print(f"❌ {e}")
+            raise
+        
+        # 初始化文档处理器
+        print("设置文档处理器...")
+        self.doc_processor, self.vectorstore, self.retriever = initialize_document_processor()
+        
+        # 初始化评分器和路由器
+        print("初始化评分器和路由器...")
+        self.graders = initialize_graders_and_router()
+        
+        # 初始化工作流节点
+        print("设置工作流节点...")
+        self.workflow_nodes = WorkflowNodes(self.retriever, self.graders)
+        
+        # 构建工作流
+        print("构建工作流图...")
+        self.app = self._build_workflow()
+        
+        print("✅ 自适应RAG系统初始化完成！")
+    
+    def _build_workflow(self):
+        """构建工作流图"""
+        workflow = StateGraph(GraphState)
+        
+        # 定义节点
+        workflow.add_node("web_search", self.workflow_nodes.web_search)
+        workflow.add_node("retrieve", self.workflow_nodes.retrieve)
+        workflow.add_node("grade_documents", self.workflow_nodes.grade_documents)
+        workflow.add_node("generate", self.workflow_nodes.generate)
+        workflow.add_node("transform_query", self.workflow_nodes.transform_query)
+        
+        # 构建图
+        workflow.add_conditional_edges(
+            START,
+            self.workflow_nodes.route_question,
+            {
+                "web_search": "web_search",
+                "vectorstore": "retrieve",
+            },
+        )
+        workflow.add_edge("web_search", "generate")
+        workflow.add_edge("retrieve", "grade_documents")
+        workflow.add_conditional_edges(
+            "grade_documents",
+            self.workflow_nodes.decide_to_generate,
+            {
+                "transform_query": "transform_query",
+                "generate": "generate",
+            },
+        )
+        workflow.add_edge("transform_query", "retrieve")
+        workflow.add_conditional_edges(
+            "generate",
+            self.workflow_nodes.grade_generation_v_documents_and_question,
+            {
+                "not supported": "generate",
+                "useful": END,
+                "not useful": "transform_query",
+            },
+        )
+        
+        # 编译
+        return workflow.compile()
+    
+    def query(self, question: str, verbose: bool = True):
+        """
+        处理查询
+        
+        Args:
+            question (str): 用户问题
+            verbose (bool): 是否显示详细输出
+            
+        Returns:
+            str: 最终答案
+        """
+        print(f"\n🔍 处理问题: {question}")
+        print("=" * 50)
+        
+        inputs = {"question": question}
+        final_generation = None
+        
+        for output in self.app.stream(inputs):
+            for key, value in output.items():
+                if verbose:
+                    pprint(f"节点 '{key}':")
+                    # 可选：在每个节点打印完整状态
+                    # pprint(value, indent=2, width=80, depth=None)
+                final_generation = value.get("generation", final_generation)
+            if verbose:
+                pprint("\n---\n")
+        
+        print("🎯 最终答案:")
+        print("-" * 30)
+        print(final_generation)
+        print("=" * 50)
+        
+        return final_generation
+    
+    def interactive_mode(self):
+        """交互模式，允许用户持续提问"""
+        print("\n🤖 欢迎使用自适应RAG系统!")
+        print("💡 输入问题开始对话，输入 'quit' 或 'exit' 退出")
+        print("-" * 50)
+        
+        while True:
+            try:
+                question = input("\n❓ 请输入您的问题: ").strip()
+                
+                if question.lower() in ['quit', 'exit', '退出', 'q']:
+                    print("👋 感谢使用，再见!")
+                    break
+                
+                if not question:
+                    print("⚠️  请输入一个有效的问题")
+                    continue
+                
+                self.query(question)
+                
+            except KeyboardInterrupt:
+                print("\n👋 感谢使用，再见!")
+                break
+            except Exception as e:
+                print(f"❌ 发生错误: {e}")
+                print("请重试或输入 'quit' 退出")
+
+
+def main():
+    """主函数"""
+    try:
+        # 初始化系统
+        rag_system = AdaptiveRAGSystem()
+        
+        # 测试查询
+        # test_question = "AlphaCodium论文讲的是什么？"
+        test_question = "解释embedding嵌入的原理，最好列举实现过程的具体步骤"
+        rag_system.query(test_question)
+        
+        # 启动交互模式
+        rag_system.interactive_mode()
+        
+    except Exception as e:
+        print(f"❌ 系统初始化失败: {e}")
+        print("请检查配置和依赖是否正确安装")
+
+
+if __name__ == "__main__":
+    main()

main_graphrag.py

@@ -0,0 +1,293 @@
+"""
+GraphRAG集成示例
+展示如何在自适应RAG系统中使用知识图谱功能
+"""
+
+import os
+from pprint import pprint
+
+from config import (
+    setup_environment, 
+    ENABLE_GRAPHRAG,
+    GRAPHRAG_INDEX_PATH,
+    GRAPHRAG_BATCH_SIZE
+)
+from document_processor import initialize_document_processor
+from graph_indexer import initialize_graph_indexer
+from graph_retriever import initialize_graph_retriever
+
+
+class AdaptiveRAGWithGraph:
+    """集成GraphRAG的自适应RAG系统"""
+    
+    def __init__(self, enable_graphrag=True, rebuild_index=False):
+        print("🚀 初始化集成GraphRAG的自适应RAG系统...")
+        print("="*60)
+        
+        # 设置环境
+        try:
+            setup_environment()
+            print("✅ 环境配置完成")
+        except ValueError as e:
+            print(f"❌ {e}")
+            raise
+        
+        # 初始化文档处理器
+        print("\n📚 初始化文档处理器...")
+        self.doc_processor, self.vectorstore, self.retriever, self.doc_splits = \
+            initialize_document_processor()
+        
+        # GraphRAG组件
+        self.enable_graphrag = enable_graphrag and ENABLE_GRAPHRAG
+        self.graph_indexer = None
+        self.graph_retriever = None
+        self.knowledge_graph = None
+        
+        if self.enable_graphrag:
+            self._setup_graphrag(rebuild_index)
+        
+        print("\n" + "="*60)
+        print("✅ 系统初始化完成!")
+        print("="*60)
+    
+    def _setup_graphrag(self, rebuild_index=False):
+        """设置GraphRAG组件"""
+        print("\n🔷 设置GraphRAG组件...")
+        
+        # 初始化索引器
+        self.graph_indexer = initialize_graph_indexer()
+        
+        # 检查是否已有索引
+        index_exists = os.path.exists(GRAPHRAG_INDEX_PATH)
+        
+        if index_exists and not rebuild_index:
+            print(f"📂 发现现有索引: {GRAPHRAG_INDEX_PATH}")
+            print("   加载现有索引...")
+            self.knowledge_graph = self.graph_indexer.load_index(GRAPHRAG_INDEX_PATH)
+        else:
+            if rebuild_index:
+                print("🔄 重新构建索引...")
+            else:
+                print("📝 首次构建索引...")
+            
+            # 构建索引
+            self.knowledge_graph = self.graph_indexer.index_documents(
+                documents=self.doc_splits,
+                batch_size=GRAPHRAG_BATCH_SIZE,
+                save_path=GRAPHRAG_INDEX_PATH
+            )
+        
+        # 初始化检索器
+        self.graph_retriever = initialize_graph_retriever(self.knowledge_graph)
+        print("✅ GraphRAG组件设置完成")
+    
+    def query_vector_only(self, question: str) -> str:
+        """仅使用向量检索"""
+        print(f"\n{'='*60}")
+        print(f"🔍 向量检索模式")
+        print(f"问题: {question}")
+        print(f"{'='*60}")
+        
+        docs = self.retriever.get_relevant_documents(question)
+        
+        print(f"\n📄 检索到 {len(docs)} 个文档片段:")
+        for i, doc in enumerate(docs[:3], 1):
+            print(f"\n片段 {i}:")
+            print(f"{doc.page_content[:200]}...")
+        
+        return self.doc_processor.format_docs(docs)
+    
+    def query_graph_local(self, question: str) -> str:
+        """使用图谱本地查询"""
+        if not self.enable_graphrag:
+            return "GraphRAG未启用"
+        
+        print(f"\n{'='*60}")
+        print(f"🔎 图谱本地查询模式")
+        print(f"问题: {question}")
+        print(f"{'='*60}")
+        
+        answer = self.graph_retriever.local_query(question)
+        
+        print(f"\n💡 答案:")
+        print(answer)
+        
+        return answer
+    
+    def query_graph_global(self, question: str) -> str:
+        """使用图谱全局查询"""
+        if not self.enable_graphrag:
+            return "GraphRAG未启用"
+        
+        print(f"\n{'='*60}")
+        print(f"🌍 图谱全局查询模式")
+        print(f"问题: {question}")
+        print(f"{'='*60}")
+        
+        answer = self.graph_retriever.global_query(question)
+        
+        print(f"\n💡 答案:")
+        print(answer)
+        
+        return answer
+    
+    def query_hybrid(self, question: str) -> dict:
+        """混合查询：向量 + 图谱"""
+        if not self.enable_graphrag:
+            return {"error": "GraphRAG未启用"}
+        
+        print(f"\n{'='*60}")
+        print(f"🔀 混合查询模式")
+        print(f"问题: {question}")
+        print(f"{'='*60}")
+        
+        # 向量检索
+        vector_docs = self.retriever.get_relevant_documents(question)
+        vector_context = self.doc_processor.format_docs(vector_docs[:3])
+        
+        # 图谱查询
+        graph_results = self.graph_retriever.hybrid_query(question)
+        
+        result = {
+            "question": question,
+            "vector_retrieval": {
+                "doc_count": len(vector_docs),
+                "context": vector_context[:500] + "..." if len(vector_context) > 500 else vector_context
+            },
+            "graph_local": graph_results["local"],
+            "graph_global": graph_results["global"]
+        }
+        
+        print("\n📊 结果汇总:")
+        print(f"  • 向量检索: {len(vector_docs)} 个文档")
+        print(f"  • 图谱本地查询完成")
+        print(f"  • 图谱全局查询完成")
+        
+        return result
+    
+    def query_smart(self, question: str) -> str:
+        """智能查询：自动选择最佳策略"""
+        if not self.enable_graphrag:
+            return self.query_vector_only(question)
+        
+        print(f"\n{'='*60}")
+        print(f"🧠 智能查询模式")
+        print(f"问题: {question}")
+        print(f"{'='*60}")
+        
+        answer = self.graph_retriever.smart_query(question)
+        
+        print(f"\n💡 答案:")
+        print(answer)
+        
+        return answer
+    
+    def get_graph_statistics(self):
+        """获取知识图谱统计信息"""
+        if not self.enable_graphrag or not self.knowledge_graph:
+            print("GraphRAG未启用或图谱未构建")
+            return
+        
+        stats = self.knowledge_graph.get_statistics()
+        
+        print("\n" + "="*60)
+        print("📊 知识图谱统计信息")
+        print("="*60)
+        print(f"节点数: {stats['num_nodes']}")
+        print(f"边数: {stats['num_edges']}")
+        print(f"社区数: {stats['num_communities']}")
+        print(f"图密度: {stats['density']:.4f}")
+        print("\n实体类型分布:")
+        for etype, count in stats['entity_types'].items():
+            print(f"  • {etype}: {count}")
+        print("="*60)
+        
+        return stats
+    
+    def interactive_mode(self):
+        """交互模式"""
+        print("\n" + "="*60)
+        print("🤖 欢迎使用GraphRAG增强的自适应RAG系统!")
+        print("="*60)
+        print("\n查询模式:")
+        print("  1️⃣  vector   - 仅向量检索")
+        print("  2️⃣  local    - 图谱本地查询")
+        print("  3️⃣  global   - 图谱全局查询")
+        print("  4️⃣  hybrid   - 混合查询")
+        print("  5️⃣  smart    - 智能查询（推荐）")
+        print("  6️⃣  stats    - 显示图谱统计")
+        print("  7️⃣  quit     - 退出")
+        print("-"*60)
+        
+        while True:
+            try:
+                mode = input("\n选择模式 (1-7): ").strip()
+                
+                if mode in ['7', 'quit', 'exit', '退出', 'q']:
+                    print("👋 感谢使用，再见!")
+                    break
+                
+                if mode in ['6', 'stats']:
+                    self.get_graph_statistics()
+                    continue
+                
+                question = input("❓ 请输入问题: ").strip()
+                
+                if not question:
+                    print("⚠️  请输入有效问题")
+                    continue
+                
+                if mode in ['1', 'vector']:
+                    self.query_vector_only(question)
+                elif mode in ['2', 'local']:
+                    self.query_graph_local(question)
+                elif mode in ['3', 'global']:
+                    self.query_graph_global(question)
+                elif mode in ['4', 'hybrid']:
+                    result = self.query_hybrid(question)
+                    pprint(result)
+                else:  # 默认智能模式
+                    self.query_smart(question)
+                
+            except KeyboardInterrupt:
+                print("\n👋 感谢使用，再见!")
+                break
+            except Exception as e:
+                print(f"❌ 发生错误: {e}")
+                print("请重试或输入 'quit' 退出")
+
+
+def main():
+    """主函数"""
+    try:
+        # 初始化系统（首次运行设置rebuild_index=True）
+        rag_system = AdaptiveRAGWithGraph(
+            enable_graphrag=True,
+            rebuild_index=False  # 设为True重新构建索引
+        )
+        
+        # 显示图谱统计
+        rag_system.get_graph_statistics()
+        
+        # 测试查询
+        print("\n" + "="*60)
+        print("🧪 测试查询示例")
+        print("="*60)
+        
+        # 示例1: 本地查询
+        rag_system.query_graph_local("LLM Agent的主要组成部分是什么？")
+        
+        # 示例2: 全局查询  
+        rag_system.query_graph_global("这些文档主要讨论了什么主题？")
+        
+        # 启动交互模式
+        rag_system.interactive_mode()
+        
+    except Exception as e:
+        print(f"❌ 系统初始化失败: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,44 @@
+# 自适应RAG系统依赖文件
+# 运行以下命令安装: pip install -r requirements.txt
+
+# 核心框架
+langchain>=0.1.0
+langgraph>=0.0.40
+langchain-community>=0.0.20
+langchain-core>=0.1.0
+
+# LLM集成
+langchain-ollama>=0.1.0
+
+# 向量数据库和嵌入
+chromadb>=0.4.0
+sentence-transformers>=2.2.0
+torch>=2.0.0
+transformers>=4.30.0
+
+# 文档处理
+tiktoken>=0.5.0
+beautifulsoup4>=4.12.0
+requests>=2.31.0
+
+# 网络搜索
+tavily-python>=0.3.0
+
+# 数据处理
+numpy>=1.24.0,<2.0  # 避免NumPy 2.x兼容性问题
+pandas>=2.0.0
+
+# 工具库
+python-dotenv>=1.0.0
+pydantic>=2.0.0
+typing-extensions>=4.0.0
+
+# 开发工具（可选）
+jupyter>=1.0.0
+ipykernel>=6.0.0
+matplotlib>=3.7.0
+seaborn>=0.12.0
+
+# GraphRAG相关（可选）
+networkx>=3.1  # 图结构处理
+python-louvain>=0.16  # 社区检测

requirements_gpu.txt

@@ -0,0 +1,56 @@
+# GPU优化版依赖文件 - 针对RTX 4090 Linux环境
+# 安装命令: pip install -r requirements_gpu.txt
+
+# 核心框架
+langchain>=0.1.0
+langgraph>=0.0.40
+langchain-community>=0.0.20
+langchain-core>=0.1.0
+
+# LLM集成
+langchain-ollama>=0.1.0
+
+# 向量数据库和嵌入（GPU优化版本）
+chromadb>=0.4.0
+sentence-transformers>=2.2.0
+
+# PyTorch GPU版本（CUDA 11.8支持）
+--index-url https://download.pytorch.org/whl/cu118
+torch>=2.0.0+cu118
+torchvision>=0.15.0+cu118
+torchaudio>=2.0.0+cu118
+
+# Transformers和加速库
+transformers>=4.30.0
+accelerate>=0.20.0
+
+# GPU加速向量搜索
+faiss-gpu>=1.7.4
+
+# CUDA支持库
+cupy-cuda12x>=12.0.0
+
+# 文档处理
+tiktoken>=0.5.0
+beautifulsoup4>=4.12.0
+requests>=2.31.0
+
+# 网络搜索
+tavily-python>=0.3.0
+
+# 数据处理（兼容版本）
+numpy>=1.24.0,<2.0
+pandas>=2.0.0
+
+# 工具库
+python-dotenv>=1.0.0
+pydantic>=2.0.0
+typing-extensions>=4.0.0
+
+# 系统监控
+gputil>=1.4.0
+psutil>=5.9.0
+
+# 可选：Jupyter支持
+jupyter>=1.0.0
+ipykernel>=6.0.0

requirements_graphrag.txt

@@ -0,0 +1,31 @@
+# GraphRAG额外依赖
+# 在原有requirements.txt基础上添加这些包
+# 安装命令: pip install -r requirements_graphrag.txt
+
+# 图数据库
+neo4j>=5.14.0
+py2neo>=2021.2.3
+
+# 或者使用更轻量的选项
+networkx>=3.1
+python-louvain>=0.16  # 社区检测
+
+# 图谱处理
+graspologic>=3.3.0  # 层次化社区检测
+leidenalg>=0.10.0  # 更好的社区检测算法
+
+# GraphRAG核心（可选，如果使用Microsoft官方实现）
+# graphrag>=0.1.0
+
+# 实体识别增强
+spacy>=3.7.0
+# 下载模型: python -m spacy download zh_core_web_sm
+# 下载模型: python -m spacy download en_core_web_sm
+
+# 图可视化（可选）
+pyvis>=0.3.2
+plotly>=5.18.0
+
+# 缓存和性能优化
+diskcache>=5.6.0
+joblib>=1.3.0

reranker.py

@@ -0,0 +1,350 @@
+"""
+向量重排模块
+实现多种重排策略以提高检索质量
+"""
+
+import torch
+import numpy as np
+from typing import List, Tuple, Dict
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+import re
+from collections import Counter
+import math
+
+
+class DocumentReranker:
+    """文档重排器基类"""
+    
+    def __init__(self):
+        self.name = "BaseReranker"
+    
+    def rerank(self, query: str, documents: List[dict], top_k: int = 5) -> List[Tuple[dict, float]]:
+        """重排文档并返回top_k结果"""
+        raise NotImplementedError
+
+
+class TFIDFReranker(DocumentReranker):
+    """基于TF-IDF的重排器"""
+    
+    def __init__(self):
+        super().__init__()
+        self.name = "TFIDFReranker"
+        self.vectorizer = TfidfVectorizer(stop_words='english', max_features=5000)
+    
+    def rerank(self, query: str, documents: List[dict], top_k: int = 5) -> List[Tuple[dict, float]]:
+        """使用TF-IDF重新排序文档"""
+        if not documents:
+            return []
+        
+        # 提取文档内容
+        doc_texts = [doc.page_content if hasattr(doc, 'page_content') else str(doc) for doc in documents]
+        all_texts = [query] + doc_texts
+        
+        # 计算TF-IDF矩阵
+        tfidf_matrix = self.vectorizer.fit_transform(all_texts)
+        query_vec = tfidf_matrix[0]
+        doc_vecs = tfidf_matrix[1:]
+        
+        # 计算相似度
+        similarities = cosine_similarity(query_vec, doc_vecs).flatten()
+        
+        # 排序并返回top_k
+        ranked_indices = np.argsort(similarities)[::-1]
+        results = []
+        for i in ranked_indices[:top_k]:
+            results.append((documents[i], float(similarities[i])))
+        
+        return results
+
+
+class BM25Reranker(DocumentReranker):
+    """基于BM25算法的重排器"""
+    
+    def __init__(self, k1: float = 1.5, b: float = 0.75):
+        super().__init__()
+        self.name = "BM25Reranker"
+        self.k1 = k1
+        self.b = b
+    
+    def _tokenize(self, text: str) -> List[str]:
+        """简单分词"""
+        return re.findall(r'\b\w+\b', text.lower())
+    
+    def _compute_idf(self, documents: List[str], query_terms: List[str]) -> Dict[str, float]:
+        """计算IDF值"""
+        N = len(documents)
+        idf = {}
+        
+        for term in query_terms:
+            df = sum(1 for doc in documents if term in self._tokenize(doc))
+            idf[term] = math.log((N - df + 0.5) / (df + 0.5))
+        
+        return idf
+    
+    def _bm25_score(self, query_terms: List[str], document: str, avg_doc_len: float, idf: Dict[str, float]) -> float:
+        """计算BM25分数"""
+        doc_terms = self._tokenize(document)
+        doc_len = len(doc_terms)
+        term_freq = Counter(doc_terms)
+        
+        score = 0.0
+        for term in query_terms:
+            if term in term_freq:
+                tf = term_freq[term]
+                score += idf.get(term, 0) * (tf * (self.k1 + 1)) / (
+                    tf + self.k1 * (1 - self.b + self.b * doc_len / avg_doc_len)
+                )
+        
+        return score
+    
+    def rerank(self, query: str, documents: List[dict], top_k: int = 5) -> List[Tuple[dict, float]]:
+        """使用BM25重新排序文档"""
+        if not documents:
+            return []
+        
+        query_terms = self._tokenize(query)
+        doc_texts = [doc.page_content if hasattr(doc, 'page_content') else str(doc) for doc in documents]
+        
+        # 计算平均文档长度
+        avg_doc_len = sum(len(self._tokenize(doc)) for doc in doc_texts) / len(doc_texts)
+        
+        # 计算IDF
+        idf = self._compute_idf(doc_texts, query_terms)
+        
+        # 计算BM25分数
+        scores = []
+        for doc_text in doc_texts:
+            score = self._bm25_score(query_terms, doc_text, avg_doc_len, idf)
+            scores.append(score)
+        
+        # 排序并返回top_k
+        ranked_indices = np.argsort(scores)[::-1]
+        results = []
+        for i in ranked_indices[:top_k]:
+            results.append((documents[i], float(scores[i])))
+        
+        return results
+
+
+class SemanticReranker(DocumentReranker):
+    """基于语义相似度的重排器"""
+    
+    def __init__(self, embeddings_model):
+        super().__init__()
+        self.name = "SemanticReranker"
+        self.embeddings_model = embeddings_model
+    
+    def rerank(self, query: str, documents: List[dict], top_k: int = 5) -> List[Tuple[dict, float]]:
+        """使用语义相似度重新排序文档"""
+        if not documents:
+            return []
+        
+        # 获取查询嵌入
+        query_embedding = self.embeddings_model.embed_query(query)
+        
+        # 获取文档嵌入
+        doc_texts = [doc.page_content if hasattr(doc, 'page_content') else str(doc) for doc in documents]
+        doc_embeddings = self.embeddings_model.embed_documents(doc_texts)
+        
+        # 计算余弦相似度
+        similarities = []
+        for doc_emb in doc_embeddings:
+            sim = cosine_similarity([query_embedding], [doc_emb])[0][0]
+            similarities.append(sim)
+        
+        # 排序并返回top_k
+        ranked_indices = np.argsort(similarities)[::-1]
+        results = []
+        for i in ranked_indices[:top_k]:
+            results.append((documents[i], float(similarities[i])))
+        
+        return results
+
+
+class HybridReranker(DocumentReranker):
+    """混合重排器，融合多种策略"""
+    
+    def __init__(self, embeddings_model, weights: Dict[str, float] = None):
+        super().__init__()
+        self.name = "HybridReranker"
+        
+        # 初始化各种重排器
+        self.tfidf_reranker = TFIDFReranker()
+        self.bm25_reranker = BM25Reranker()
+        self.semantic_reranker = SemanticReranker(embeddings_model)
+        
+        # 设置权重
+        self.weights = weights or {
+            'tfidf': 0.3,
+            'bm25': 0.3,
+            'semantic': 0.4
+        }
+    
+    def rerank(self, query: str, documents: List[dict], top_k: int = 5) -> List[Tuple[dict, float]]:
+        """使用混合策略重新排序文档"""
+        if not documents:
+            return []
+        
+        # 获取各种重排结果
+        tfidf_results = self.tfidf_reranker.rerank(query, documents, len(documents))
+        bm25_results = self.bm25_reranker.rerank(query, documents, len(documents))
+        semantic_results = self.semantic_reranker.rerank(query, documents, len(documents))
+        
+        # 创建文档到分数的映射
+        doc_scores = {}
+        for doc in documents:
+            doc_id = id(doc)
+            doc_scores[doc_id] = {'doc': doc, 'tfidf': 0, 'bm25': 0, 'semantic': 0}
+        
+        # 填充各种分数
+        for doc, score in tfidf_results:
+            doc_scores[id(doc)]['tfidf'] = score
+        
+        for doc, score in bm25_results:
+            doc_scores[id(doc)]['bm25'] = score
+        
+        for doc, score in semantic_results:
+            doc_scores[id(doc)]['semantic'] = score
+        
+        # 归一化分数
+        for score_type in ['tfidf', 'bm25', 'semantic']:
+            scores = [info[score_type] for info in doc_scores.values()]
+            if max(scores) > 0:
+                max_score = max(scores)
+                for doc_id in doc_scores:
+                    doc_scores[doc_id][score_type] /= max_score
+        
+        # 计算综合分数
+        final_scores = []
+        for doc_id, info in doc_scores.items():
+            combined_score = (
+                self.weights['tfidf'] * info['tfidf'] +
+                self.weights['bm25'] * info['bm25'] +
+                self.weights['semantic'] * info['semantic']
+            )
+            final_scores.append((info['doc'], combined_score))
+        
+        # 排序并返回top_k
+        final_scores.sort(key=lambda x: x[1], reverse=True)
+        return final_scores[:top_k]
+
+
+class DiversityReranker(DocumentReranker):
+    """多样性重排器，避免结果重复"""
+    
+    def __init__(self, embeddings_model, diversity_lambda: float = 0.5):
+        super().__init__()
+        self.name = "DiversityReranker"
+        self.embeddings_model = embeddings_model
+        self.diversity_lambda = diversity_lambda
+    
+    def _calculate_diversity_penalty(self, candidate_doc: str, selected_docs: List[str]) -> float:
+        """计算多样性惩罚"""
+        if not selected_docs:
+            return 0.0
+        
+        candidate_emb = self.embeddings_model.embed_documents([candidate_doc])[0]
+        selected_embs = self.embeddings_model.embed_documents(selected_docs)
+        
+        max_similarity = 0.0
+        for selected_emb in selected_embs:
+            sim = cosine_similarity([candidate_emb], [selected_emb])[0][0]
+            max_similarity = max(max_similarity, sim)
+        
+        return max_similarity
+    
+    def rerank(self, query: str, documents: List[dict], top_k: int = 5) -> List[Tuple[dict, float]]:
+        """使用多样性策略重新排序文档"""
+        if not documents:
+            return []
+        
+        # 首先使用语义相似度获取初始排序
+        semantic_results = SemanticReranker(self.embeddings_model).rerank(
+            query, documents, len(documents)
+        )
+        
+        # MMR (Maximal Marginal Relevance) 算法
+        selected_docs = []
+        selected_texts = []
+        remaining_docs = [doc for doc, _ in semantic_results]
+        relevance_scores = {id(doc): score for doc, score in semantic_results}
+        
+        while len(selected_docs) < top_k and remaining_docs:
+            best_score = -1
+            best_doc = None
+            best_idx = -1
+            
+            for i, doc in enumerate(remaining_docs):
+                doc_text = doc.page_content if hasattr(doc, 'page_content') else str(doc)
+                relevance = relevance_scores[id(doc)]
+                diversity_penalty = self._calculate_diversity_penalty(doc_text, selected_texts)
+                
+                # MMR分数 = λ * 相关性 - (1-λ) * 多样性惩罚
+                mmr_score = (
+                    self.diversity_lambda * relevance - 
+                    (1 - self.diversity_lambda) * diversity_penalty
+                )
+                
+                if mmr_score > best_score:
+                    best_score = mmr_score
+                    best_doc = doc
+                    best_idx = i
+            
+            if best_doc is not None:
+                selected_docs.append((best_doc, best_score))
+                selected_texts.append(
+                    best_doc.page_content if hasattr(best_doc, 'page_content') else str(best_doc)
+                )
+                remaining_docs.pop(best_idx)
+        
+        return selected_docs
+
+
+def create_reranker(reranker_type: str, embeddings_model=None, **kwargs) -> DocumentReranker:
+    """工厂函数：创建指定类型的重排器"""
+    
+    if reranker_type.lower() == 'tfidf':
+        return TFIDFReranker()
+    elif reranker_type.lower() == 'bm25':
+        return BM25Reranker(**kwargs)
+    elif reranker_type.lower() == 'semantic':
+        if embeddings_model is None:
+            raise ValueError("SemanticReranker requires embeddings_model")
+        return SemanticReranker(embeddings_model)
+    elif reranker_type.lower() == 'hybrid':
+        if embeddings_model is None:
+            raise ValueError("HybridReranker requires embeddings_model")
+        return HybridReranker(embeddings_model, **kwargs)
+    elif reranker_type.lower() == 'diversity':
+        if embeddings_model is None:
+            raise ValueError("DiversityReranker requires embeddings_model")
+        return DiversityReranker(embeddings_model, **kwargs)
+    else:
+        raise ValueError(f"Unknown reranker type: {reranker_type}")
+
+
+# 使用示例
+if __name__ == "__main__":
+    # 模拟文档
+    class MockDoc:
+        def __init__(self, content):
+            self.page_content = content
+    
+    docs = [
+        MockDoc("人工智能是计算机科学的一个分支"),
+        MockDoc("机器学习是人工智能的子领域"),
+        MockDoc("深度学习使用神经网络"),
+        MockDoc("自然语言处理处理文本数据"),
+        MockDoc("今天天气很好")
+    ]
+    
+    query = "什么是人工智能？"
+    
+    # 测试TF-IDF重排
+    tfidf_reranker = TFIDFReranker()
+    results = tfidf_reranker.rerank(query, docs, top_k=3)
+    
+    print("TF-IDF重排结果:")
+    for doc, score in results:
+        print(f"分数: {score:.4f} - 内容: {doc.page_content}")

routers_and_graders.py

@@ -0,0 +1,147 @@
+"""
+路由器和评分器模块
+包含查询路由、文档相关性评分、答案质量评分和幻觉检测
+"""
+
+from langchain.prompts import PromptTemplate
+from langchain_community.chat_models import ChatOllama
+from langchain_core.output_parsers import JsonOutputParser, StrOutputParser
+
+from config import LOCAL_LLM
+
+
+class QueryRouter:
+    """查询路由器，决定使用向量存储还是网络搜索"""
+    
+    def __init__(self):
+        self.llm = ChatOllama(model=LOCAL_LLM, format="json", temperature=0)
+        self.prompt = PromptTemplate(
+            template="""你是一个专家，负责将用户问题路由到向量存储或网络搜索。
+            对于关于LLM智能体、提示工程和对抗性攻击的问题，使用向量存储。
+            你不需要严格匹配问题中与这些主题相关的关键词。
+            否则，使用网络搜索。根据问题给出二进制选择'web_search'或'vectorstore'。
+            返回一个只包含'datasource'键的JSON，不要前言或解释。
+            要路由的问题：{question}""",
+            input_variables=["question"],
+        )
+        self.router = self.prompt | self.llm | JsonOutputParser()
+    
+    def route(self, question: str) -> str:
+        """路由问题到相应的数据源"""
+        result = self.router.invoke({"question": question})
+        return result.get("datasource", "web_search")
+
+
+class DocumentGrader:
+    """文档相关性评分器"""
+    
+    def __init__(self):
+        self.llm = ChatOllama(model=LOCAL_LLM, format="json", temperature=0)
+        self.prompt = PromptTemplate(
+            template="""你是一个评分员，评估检索到的文档是否与用户问题相关。
+            如果文档包含与用户问题相关的关键词或语义，请给出'yes'分数。
+            给出二进制分数'yes'或'no'，以表明文档是否与问题相关。
+            将二进制分数作为JSON提供，只包含'score'键，不要前言或解释。
+            
+            检索到的文档：
+
+ {document} 
+
+
+            用户问题：{question}""",
+            input_variables=["question", "document"],
+        )
+        self.grader = self.prompt | self.llm | JsonOutputParser()
+    
+    def grade(self, question: str, document: str) -> str:
+        """评估文档与问题的相关性"""
+        result = self.grader.invoke({"question": question, "document": document})
+        return result.get("score", "no")
+
+
+class AnswerGrader:
+    """答案质量评分器"""
+    
+    def __init__(self):
+        self.llm = ChatOllama(model=LOCAL_LLM, format="json", temperature=0)
+        self.prompt = PromptTemplate(
+            template="""你是一个评分员，评估答案是否有助于解决问题。
+            这里是答案：
+            \n ------- \n
+            {generation} 
+            \n ------- \n
+            这里是问题：{question}
+            给出二进制分数'yes'或'no'，表示答案是否有助于解决问题。
+            将二进制分数作为JSON提供，只包含'score'键，不要前言或解释。""",
+            input_variables=["generation", "question"],
+        )
+        self.grader = self.prompt | self.llm | JsonOutputParser()
+    
+    def grade(self, question: str, generation: str) -> str:
+        """评估答案质量"""
+        result = self.grader.invoke({"question": question, "generation": generation})
+        return result.get("score", "no")
+
+
+class HallucinationGrader:
+    """幻觉检测器"""
+    
+    def __init__(self):
+        self.llm = ChatOllama(model=LOCAL_LLM, format="json", temperature=0)
+        self.prompt = PromptTemplate(
+            template="""你是一个评分员，评估LLM生成是否基于/支持一组检索到的事实。
+            给出二进制分数'yes'或'no'。'yes'意味着答案基于/支持文档。
+            将二进制分数作为JSON提供，只包含'score'键，不要前言或解释。
+            
+            检索到的文档：
+
+ {documents} 
+
+
+            LLM生成：{generation}""",
+            input_variables=["generation", "documents"],
+        )
+        self.grader = self.prompt | self.llm | JsonOutputParser()
+    
+    def grade(self, generation: str, documents) -> str:
+        """检测生成内容是否存在幻觉"""
+        result = self.grader.invoke({"generation": generation, "documents": documents})
+        return result.get("score", "no")
+
+
+class QueryRewriter:
+    """查询重写器，优化查询以获得更好的检索结果"""
+    
+    def __init__(self):
+        self.llm = ChatOllama(model=LOCAL_LLM, temperature=0)
+        self.prompt = PromptTemplate(
+            template="""你是一个问题重写器，将输入问题转换为更适合向量存储检索的更好版本。
+            查看初始问题并制定一个改进的问题。
+            这里是初始问题：\n\n {question}。改进的问题（无前言）：\n """,
+            input_variables=["question"],
+        )
+        self.rewriter = self.prompt | self.llm | StrOutputParser()
+    
+    def rewrite(self, question: str) -> str:
+        """重写查询以获得更好的检索效果"""
+        print(f"---原始查询: {question}---")
+        rewritten_query = self.rewriter.invoke({"question": question})
+        print(f"---重写查询: {rewritten_query}---")
+        return rewritten_query
+
+
+def initialize_graders_and_router():
+    """初始化所有评分器和路由器"""
+    query_router = QueryRouter()
+    document_grader = DocumentGrader()
+    answer_grader = AnswerGrader()
+    hallucination_grader = HallucinationGrader()
+    query_rewriter = QueryRewriter()
+    
+    return {
+        "query_router": query_router,
+        "document_grader": document_grader,
+        "answer_grader": answer_grader,
+        "hallucination_grader": hallucination_grader,
+        "query_rewriter": query_rewriter
+    }

test_reranking.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python3
+"""
+重排功能测试脚本
+演示不同重排策略的效果
+"""
+
+import sys
+import os
+sys.path.append(os.path.dirname(__file__))
+
+from document_processor import DocumentProcessor
+from reranker import *
+from langchain.schema import Document
+import time
+
+
+def create_test_documents():
+    """创建测试文档"""
+    return [
+        Document(
+            page_content="人工智能（AI）是计算机科学的一个分支，致力于创建能够执行通常需要人类智能的任务的系统。",
+            metadata={"source": "ai_intro.txt", "category": "AI基础"}
+        ),
+        Document(
+            page_content="机器学习是人工智能的一个重要子领域，通过算法让计算机从数据中学习模式和规律。",
+            metadata={"source": "ml_basics.txt", "category": "机器学习"}
+        ),
+        Document(
+            page_content="深度学习是机器学习的一个分支，使用多层神经网络来模拟人脑的学习过程。",
+            metadata={"source": "dl_guide.txt", "category": "深度学习"}
+        ),
+        Document(
+            page_content="自然语言处理（NLP）是人工智能领域的一个重要分支，专注于使计算机理解和处理人类语言。",
+            metadata={"source": "nlp_overview.txt", "category": "自然语言处理"}
+        ),
+        Document(
+            page_content="计算机视觉是人工智能的另一个重要领域，使计算机能够识别和理解图像和视频内容。",
+            metadata={"source": "cv_intro.txt", "category": "计算机视觉"}
+        ),
+        Document(
+            page_content="强化学习是机器学习的一种类型，通过与环境交互来学习最优的行为策略。",
+            metadata={"source": "rl_basics.txt", "category": "强化学习"}
+        ),
+        Document(
+            page_content="今天的天气非常好，阳光明媚，适合外出游玩和运动。",
+            metadata={"source": "weather.txt", "category": "天气"}
+        ),
+        Document(
+            page_content="区块链是一种分布式账本技术，具有去中心化、不可篡改等特点。",
+            metadata={"source": "blockchain.txt", "category": "区块链"}
+        )
+    ]
+
+
+def test_reranker_comparison():
+    """比较不同重排器的效果"""
+    print("🔍 重排器效果比较测试")
+    print("=" * 60)
+    
+    # 创建测试数据
+    query = "什么是人工智能和机器学习？"
+    documents = create_test_documents()
+    
+    # 创建一个简单的嵌入模型（用于测试）
+    try:
+        from langchain_community.embeddings import HuggingFaceEmbeddings
+        embeddings = HuggingFaceEmbeddings(
+            model_name="sentence-transformers/all-MiniLM-L6-v2",
+            model_kwargs={'device': 'cpu'}
+        )
+        print("✅ 成功加载嵌入模型")
+    except Exception as e:
+        print(f"❌ 嵌入模型加载失败: {e}")
+        print("将使用基础重排器进行测试")
+        embeddings = None
+    
+    # 测试不同的重排器
+    rerankers = []
+    
+    # TF-IDF重排器
+    rerankers.append(("TF-IDF", TFIDFReranker()))
+    
+    # BM25重排器
+    rerankers.append(("BM25", BM25Reranker()))
+    
+    if embeddings:
+        # 语义重排器
+        rerankers.append(("语义相似度", SemanticReranker(embeddings)))
+        
+        # 混合重排器
+        rerankers.append(("混合策略", HybridReranker(embeddings)))
+        
+        # 多样性重排器
+        rerankers.append(("多样性优化", DiversityReranker(embeddings)))
+    
+    # 执行测试
+    for name, reranker in rerankers:
+        print(f"\n📊 {name} 重排结果:")
+        print("-" * 40)
+        
+        start_time = time.time()
+        try:
+            results = reranker.rerank(query, documents, top_k=5)
+            end_time = time.time()
+            
+            print(f"⏱️ 处理时间: {(end_time - start_time)*1000:.2f}ms")
+            
+            for i, (doc, score) in enumerate(results, 1):
+                content = doc.page_content[:80] + "..." if len(doc.page_content) > 80 else doc.page_content
+                category = doc.metadata.get('category', '未知')
+                print(f"{i}. [分数: {score:.4f}] [{category}] {content}")
+                
+        except Exception as e:
+            print(f"❌ 重排失败: {e}")
+
+
+def test_reranking_with_embeddings():
+    """测试带嵌入的重排功能"""
+    print("\n\n🧠 嵌入模型重排测试")
+    print("=" * 60)
+    
+    try:
+        # 创建文档处理器
+        processor = DocumentProcessor()
+        
+        # 创建测试文档
+        test_docs = create_test_documents()
+        
+        # 测试查询
+        queries = [
+            "人工智能的定义是什么？",
+            "机器学习和深度学习的区别",
+            "自然语言处理的应用",
+            "今天天气怎么样？"
+        ]
+        
+        for query in queries:
+            print(f"\n🔍 查询: {query}")
+            print("-" * 30)
+            
+            if processor.reranker:
+                # 使用重排功能
+                results = processor.reranker.rerank(query, test_docs, top_k=3)
+                
+                for i, (doc, score) in enumerate(results, 1):
+                    content = doc.page_content[:60] + "..." if len(doc.page_content) > 60 else doc.page_content
+                    category = doc.metadata.get('category', '未知')
+                    print(f"{i}. [分数: {score:.4f}] [{category}] {content}")
+            else:
+                print("❌ 重排器未初始化")
+                
+    except Exception as e:
+        print(f"❌ 测试失败: {e}")
+
+
+def test_performance_comparison():
+    """性能对比测试"""
+    print("\n\n⚡ 性能对比测试")
+    print("=" * 60)
+    
+    documents = create_test_documents() * 10  # 增加文档数量
+    query = "人工智能技术的发展趋势"
+    
+    # 测试不同重排器的性能
+    rerankers_config = [
+        ("无重排", None),
+        ("TF-IDF", TFIDFReranker()),
+        ("BM25", BM25Reranker())
+    ]
+    
+    for name, reranker in rerankers_config:
+        times = []
+        
+        # 多次测试取平均值
+        for _ in range(5):
+            start_time = time.time()
+            
+            if reranker:
+                results = reranker.rerank(query, documents, top_k=5)
+            else:
+                # 模拟无重排的情况
+                results = documents[:5]
+            
+            end_time = time.time()
+            times.append((end_time - start_time) * 1000)
+        
+        avg_time = sum(times) / len(times)
+        print(f"{name}: 平均处理时间 {avg_time:.2f}ms (文档数: {len(documents)})")
+
+
+def main():
+    """主测试函数"""
+    print("🚀 向量重排功能综合测试")
+    print("=" * 80)
+    
+    try:
+        # 基础重排器比较
+        test_reranker_comparison()
+        
+        # 嵌入模型重排测试
+        test_reranking_with_embeddings()
+        
+        # 性能对比测试
+        test_performance_comparison()
+        
+        print("\n\n✅ 所有测试完成!")
+        print("=" * 80)
+        
+    except KeyboardInterrupt:
+        print("\n❌ 测试被用户中断")
+    except Exception as e:
+        print(f"\n❌ 测试过程中发生错误: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    main()

workflow_nodes.py

@@ -0,0 +1,240 @@
+"""
+工作流节点模块
+包含所有工作流节点函数和状态管理
+"""
+
+from typing import List
+from typing_extensions import TypedDict
+from langchain.schema import Document
+from langchain_community.chat_models import ChatOllama
+from langchain_core.output_parsers import StrOutputParser
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain.prompts import PromptTemplate
+
+from config import LOCAL_LLM, WEB_SEARCH_RESULTS_COUNT
+from pprint import pprint
+
+
+class GraphState(TypedDict):
+    """
+    表示图的状态
+    
+    属性:
+        question: 问题
+        generation: LLM生成
+        documents: 文档列表
+    """
+    question: str
+    generation: str
+    documents: List[str]
+
+
+class WorkflowNodes:
+    """工作流节点类，包含所有节点函数"""
+    
+    def __init__(self, retriever, graders):
+        self.retriever = retriever
+        self.graders = graders
+        
+        # 设置RAG链 - 使用本地提示模板
+        rag_prompt_template = PromptTemplate(
+            template="""你是一个问答助手。使用以下检索到的上下文来回答问题。
+如果你不知道答案，就说你不知道。最多使用三句话并保持答案简洁。
+
+问题: {question}
+
+上下文: {context}
+
+答案:""",
+            input_variables=["question", "context"]
+        )
+        llm = ChatOllama(model=LOCAL_LLM, temperature=0)
+        self.rag_chain = rag_prompt_template | llm | StrOutputParser()
+        
+        # 设置网络搜索
+        self.web_search_tool = TavilySearchResults(k=WEB_SEARCH_RESULTS_COUNT)
+    
+    def retrieve(self, state):
+        """
+        检索文档
+        
+        Args:
+            state (dict): 当前图状态
+            
+        Returns:
+            state (dict): 添加了documents键的新状态，包含检索到的文档
+        """
+        print("---检索---")
+        question = state["question"]
+        
+        # 检索
+        documents = self.retriever.get_relevant_documents(question)
+        return {"documents": documents, "question": question}
+    
+    def generate(self, state):
+        """
+        生成答案
+        
+        Args:
+            state (dict): 当前图状态
+            
+        Returns:
+            state (dict): 添加了generation键的新状态，包含LLM生成
+        """
+        print("---生成---")
+        question = state["question"]
+        documents = state["documents"]
+        
+        # RAG生成
+        generation = self.rag_chain.invoke({"context": documents, "question": question})
+        return {"documents": documents, "question": question, "generation": generation}
+    
+    def grade_documents(self, state):
+        """
+        确定检索到的文档是否与问题相关
+        
+        Args:
+            state (dict): 当前图状态
+            
+        Returns:
+            state (dict): 更新documents键，只包含过滤后的相关文档
+        """
+        print("---检查文档与问题的相关性---")
+        question = state["question"]
+        documents = state["documents"]
+        
+        # 为每个文档评分
+        filtered_docs = []
+        for d in documents:
+            score = self.graders["document_grader"].grade(question, d.page_content)
+            grade = score
+            if grade == "yes":
+                print("---评分：文档相关---")
+                filtered_docs.append(d)
+            else:
+                print("---评分：文档不相关---")
+                continue
+        return {"documents": filtered_docs, "question": question}
+    
+    def transform_query(self, state):
+        """
+        转换查询以产生更好的问题
+        
+        Args:
+            state (dict): 当前图状态
+            
+        Returns:
+            state (dict): 用重新表述的问题更新question键
+        """
+        print("---转换查询---")
+        question = state["question"]
+        documents = state["documents"]
+        
+        # 重写问题
+        better_question = self.graders["query_rewriter"].rewrite(question)
+        return {"documents": documents, "question": better_question}
+    
+    def web_search(self, state):
+        """
+        基于重新表述的问题进行网络搜索
+        
+        Args:
+            state (dict): 当前图状态
+            
+        Returns:
+            state (dict): 用附加的网络结果更新documents键
+        """
+        print("---网络搜索---")
+        question = state["question"]
+        
+        # 网络搜索
+        docs = self.web_search_tool.invoke({"query": question})
+        web_results = "\n".join([d["content"] for d in docs])
+        web_results = Document(page_content=web_results)
+        
+        return {"documents": web_results, "question": question}
+    
+    def route_question(self, state):
+        """
+        将问题路由到网络搜索或RAG
+        
+        Args:
+            state (dict): 当前图状态
+            
+        Returns:
+            str: 要调用的下一个节点
+        """
+        print("---路由问题---")
+        question = state["question"]
+        print(question)
+        source = self.graders["query_router"].route(question)
+        print(source)
+        if source == "web_search":
+            print("---将问题路由到网络搜索---")
+            return "web_search"
+        elif source == "vectorstore":
+            print("---将问题路由到RAG---")
+            return "vectorstore"
+    
+    def decide_to_generate(self, state):
+        """
+        确定是生成答案还是重新生成问题
+        
+        Args:
+            state (dict): 当前图状态
+            
+        Returns:
+            str: 要调用的下一个节点的二进制决策
+        """
+        print("---评估已评分的文档---")
+        filtered_documents = state["documents"]
+        
+        if not filtered_documents:
+            # 所有文档都被过滤掉了
+            # 我们将重新生成一个新查询
+            print("---决策：所有文档都与问题不相关，转换查询---")
+            return "transform_query"
+        else:
+            # 我们有相关文档，所以生成答案
+            print("---决策：生成---")
+            return "generate"
+    
+    def grade_generation_v_documents_and_question(self, state):
+        """
+        确定生成是否基于文档并回答问题
+        
+        Args:
+            state (dict): 当前图状态
+            
+        Returns:
+            str: 要调用的下一个节点的决策
+        """
+        print("---检查幻觉---")
+        question = state["question"]
+        documents = state["documents"]
+        generation = state["generation"]
+        
+        score = self.graders["hallucination_grader"].grade(generation, documents)
+        grade = score
+        
+        # 检查幻觉
+        if grade == "yes":
+            print("---决策：生成基于文档---")
+            # 检查问题回答
+            print("---评分生成 vs 问题---")
+            score = self.graders["answer_grader"].grade(question, generation)
+            grade = score
+            if grade == "yes":
+                print("---决策：生成解决了问题---")
+                return "useful"
+            else:
+                print("---决策：生成没有解决问题---")
+                return "not useful"
+        else:
+            print("---决策：生成不基于文档，重试---")
+            return "not supported"
+
+
+def format_docs(docs):
+    """格式化文档用于显示"""
+    return "\n\n".join(doc.page_content for doc in docs)