delete urls

BATCH_FREEZE_FIX.md

@@ -1,395 +0,0 @@
-# 批次处理卡住问题 - 修复总结
-
-## 问题描述
-用户报告在处理第6批次时，GraphRAG索引过程在提取实体6次后卡住，没有错误信息。
-
-## 根本原因分析
-
-### 1. **LLM超时问题** (最可能)
-- Ollama服务在处理某些复杂文档时可能超时
-- 没有设置timeout，导致请求无限期挂起
-- 缺少重试机制
-
-### 2. **资源耗尽**
-- 连续处理多个批次后，Ollama可能积累内存
-- 连接池可能耗尽
-
-### 3. **错误处理不足**
-- 异常没有被捕获，导致静默失败
-- 缺少详细的进度日志，难以诊断
-
-## 实施的修复
-
-### ✅ 修复 1: 添加超时和重试机制
-
-**文件**: `entity_extractor.py`
-
-**改动**:
-```python
-# 之前
-class EntityExtractor:
-    def __init__(self):
-        self.llm = ChatOllama(model=LOCAL_LLM, format="json", temperature=0)
-
-# 之后
-class EntityExtractor:
-    def __init__(self, timeout: int = 60, max_retries: int = 3):
-        self.llm = ChatOllama(
-            model=LOCAL_LLM, 
-            format="json", 
-            temperature=0,
-            timeout=timeout  # 60秒超时
-        )
-        self.max_retries = max_retries
-```
-
-**效果**:
-- 每次LLM调用最多等待60秒
-- 超时后自动重试，最多3次
-- 重试间隔递增（2秒、4秒、6秒）
-
-### ✅ 修复 2: 改进的异常处理
-
-**文件**: `entity_extractor.py`
-
-**改动**:
-```python
-# 之前
-def extract_entities(self, text: str) -> List[Dict]:
-    try:
-        result = self.entity_chain.invoke({"text": text[:2000]})
-        entities = result.get("entities", [])
-        return entities
-    except Exception as e:
-        print(f"❌ 实体提取失败: {e}")
-        return []
-
-# 之后
-def extract_entities(self, text: str) -> List[Dict]:
-    for attempt in range(self.max_retries):
-        try:
-            print(f"   🔄 提取实体 (尝试 {attempt + 1}/{self.max_retries})...", end="")
-            result = self.entity_chain.invoke({"text": text[:2000]})
-            entities = result.get("entities", [])
-            print(f" ✅ 提取到 {len(entities)} 个实体")
-            return entities
-        except TimeoutError as e:
-            print(f" ⏱️ 超时")
-            if attempt < self.max_retries - 1:
-                wait_time = (attempt + 1) * 2
-                print(f"   ⏳ 等待 {wait_time} 秒后重试...")
-                time.sleep(wait_time)
-            else:
-                print(f"   ❌ 实体提取最终失败: 超时")
-                return []
-        except Exception as e:
-            print(f" ❌ 错误: {str(e)[:100]}")
-            if attempt < self.max_retries - 1:
-                time.sleep(1)
-            else:
-                return []
-    return []
-```
-
-**效果**:
-- 区分超时错误和其他错误
-- 超时后等待并重试
-- 显示详细的重试进度
-- 最终失败后返回空列表，不崩溃
-
-### ✅ 修复 3: 增强的进度跟踪
-
-**文件**: `graph_indexer.py`
-
-**改动**:
-```python
-# 之前
-for i in range(0, len(documents), batch_size):
-    batch = documents[i:i+batch_size]
-    print(f"   处理批次 {i//batch_size + 1}...")
-    for doc in batch:
-        result = self.entity_extractor.extract_from_document(doc.page_content)
-        extraction_results.append(result)
-
-# 之后
-for i in range(0, len(documents), batch_size):
-    batch = documents[i:i+batch_size]
-    batch_num = i // batch_size + 1
-    total_batches = (len(documents) - 1) // batch_size + 1
-    print(f"\n⚙️  === 批次 {batch_num}/{total_batches} (文档 {i+1}-{min(i+batch_size, len(documents))}) ===")
-    
-    for idx, doc in enumerate(batch):
-        doc_global_index = i + idx
-        try:
-            result = self.entity_extractor.extract_from_document(
-                doc.page_content, 
-                doc_index=doc_global_index
-            )
-            extraction_results.append(result)
-        except Exception as e:
-            print(f"   ❌ 文档 #{doc_global_index + 1} 处理失败: {e}")
-            extraction_results.append({"entities": [], "relations": []})
-    
-    print(f"✅ 批次 {batch_num}/{total_batches} 完成")
-```
-
-**效果**:
-- 显示当前批次号和总批次数
-- 显示正在处理的文档范围
-- 每个文档的全局索引
-- 批次级别的异常处理
-- 失败后添加空结果继续处理
-
-### ✅ 修复 4: 改进的日志输出
-
-**文件**: `entity_extractor.py`
-
-**改动**:
-```python
-# 之前
-def extract_from_document(self, document_text: str) -> Dict:
-    print("🔍 开始提取实体...")
-    entities = self.extract_entities(document_text)
-    print("🔍 开始提取关系...")
-    relations = self.extract_relations(document_text, entities)
-    return {"entities": entities, "relations": relations}
-
-# 之后
-def extract_from_document(self, document_text: str, doc_index: int = 0) -> Dict:
-    print(f"\n🔍 文档 #{doc_index + 1}: 开始提取...")
-    
-    entities = self.extract_entities(document_text)
-    relations = self.extract_relations(document_text, entities)
-    
-    print(f"📊 文档 #{doc_index + 1} 完成: {len(entities)} 实体, {len(relations)} 关系")
-    
-    return {"entities": entities, "relations": relations}
-```
-
-**效果**:
-- 显示文档编号
-- 汇总每个文档的提取结果
-- 更容易定位卡住的具体文档
-
-## 日志输出示例
-
-### 之前的输出:
-```
-📍 步骤 1/5: 实体和关系提取
-   处理批次 6/10...
-🔍 开始提取实体...
-[卡住，没有更多输出]
-```
-
-### 现在的输出:
-```
-📍 步骤 1/5: 实体和关系提取
-
-⚙️  === 批次 6/10 (文档 51-60) ===
-
-🔍 文档 #51: 开始提取...
-   🔄 提取实体 (尝试 1/3)... ✅ 提取到 5 个实体
-   🔄 提取关系 (尝试 1/3)... ✅ 提取到 3 个关系
-📊 文档 #51 完成: 5 实体, 3 关系
-
-🔍 文档 #52: 开始提取...
-   🔄 提取实体 (尝试 1/3)... ⏱️ 超时
-   ⏳ 等待 2 秒后重试...
-   🔄 提取实体 (尝试 2/3)... ✅ 提取到 7 个实体
-   🔄 提取关系 (尝试 1/3)... ✅ 提取到 4 个关系
-📊 文档 #52 完成: 7 实体, 4 关系
-
-✅ 批次 6/10 完成
-```
-
-## 如何使用修复后的代码
-
-### 方法 1: 上传到Google Drive
-
-1. 下载更新后的文件:
-   - `entity_extractor.py`
-   - `graph_indexer.py`
-   - `GRAPHRAG_TROUBLESHOOTING.md`
-
-2. 上传到 `/MyDrive/adaptive_RAG/`
-
-3. 重新运行 `main_graphrag.py`
-
-### 方法 2: 在Colab中直接应用补丁
-
-运行以下代码块：
-
-```python
-# 确保已挂载Google Drive
-from google.colab import drive
-drive.mount('/content/drive')
-
-# 更新entity_extractor.py的超时设置
-import sys
-sys.path.insert(0, '/content/drive/MyDrive/adaptive_RAG')
-
-# 重新导入更新后的模块
-import importlib
-if 'entity_extractor' in sys.modules:
-    importlib.reload(sys.modules['entity_extractor'])
-if 'graph_indexer' in sys.modules:
-    importlib.reload(sys.modules['graph_indexer'])
-```
-
-### 方法 3: 调整参数
-
-如果仍然卡住，可以调整参数：
-
-```python
-# 在初始化时增加超时和重试
-from entity_extractor import EntityExtractor
-
-extractor = EntityExtractor(
-    timeout=120,      # 增加到2分钟
-    max_retries=5     # 更多重试次数
-)
-
-# 减小批次大小
-graph = indexer.index_documents(
-    documents=doc_splits,
-    batch_size=3,     # 从10降到3
-    save_path="./knowledge_graph.pkl"
-)
-```
-
-## 紧急修复步骤
-
-如果现在就需要解决，按以下顺序尝试：
-
-### ⚡ 步骤 1: 重启Ollama (最快)
-```bash
-# 在Colab中
-!pkill -9 ollama
-!sleep 2
-!nohup ollama serve > /tmp/ollama.log 2>&1 &
-!sleep 5
-```
-
-### ⚡ 步骤 2: 减小批次大小
-```python
-# 找到调用 index_documents 的地方，修改为:
-batch_size=3  # 从默认的10改为3
-```
-
-### ⚡ 步骤 3: 从失败处继续
-```python
-# 如果在第6批次卡住，跳过前5批次
-processed_count = 50  # 5批次 × 10文档/批次
-remaining_docs = doc_splits[processed_count:]
-
-# 只处理剩余的
-graph = indexer.index_documents(
-    documents=remaining_docs,
-    batch_size=5
-)
-```
-
-## 预防措施
-
-### 1. 在开始大批量处理前测试
-```python
-# 先用小数据集测试
-test_docs = doc_splits[:5]
-test_graph = indexer.index_documents(test_docs, batch_size=2)
-print("✅ 测试成功，可以处理完整数据集")
-```
-
-### 2. 定期保存检查点
-```python
-# 每5个批次保存一次
-import pickle
-
-for batch_num in range(total_batches):
-    # 处理批次...
-    
-    if batch_num % 5 == 0:
-        checkpoint = {
-            'results': extraction_results,
-            'last_batch': batch_num
-        }
-        with open(f'/content/drive/MyDrive/checkpoint_{batch_num}.pkl', 'wb') as f:
-            pickle.dump(checkpoint, f)
-```
-
-### 3. 监控Ollama健康状态
-```python
-import requests
-
-def check_ollama_health():
-    try:
-        response = requests.get('http://localhost:11434/api/tags', timeout=5)
-        return response.status_code == 200
-    except:
-        return False
-
-# 在批次循环中
-if not check_ollama_health():
-    print("⚠️ Ollama服务异常，重启中...")
-    !pkill ollama && sleep 2 && nohup ollama serve > /tmp/ollama.log 2>&1 &
-    !sleep 5
-```
-
-## 修改的文件列表
-
-| 文件 | 修改内容 | 影响 |
-|-----|---------|------|
-| `entity_extractor.py` | 添加timeout、重试、详细日志 | 核心修复 |
-| `graph_indexer.py` | 批次级异常处理、进度跟踪 | 核心修复 |
-| `GRAPHRAG_TROUBLESHOOTING.md` | 完整的故障排除指南 | 新增文档 |
-| `BATCH_FREEZE_FIX.md` | 本文档 | 新增文档 |
-
-## 技术细节
-
-### Timeout实现
-- 使用 `ChatOllama(timeout=60)` 参数
-- 捕获 `TimeoutError` 异常
-- 实现指数退避重试策略
-
-### 异常恢复策略
-1. **轻度错误**: 重试3次，间隔递增
-2. **严重错误**: 记录并跳过，返回空结果
-3. **批次失败**: 继续处理下一批次
-
-### 进度持久化
-- 可以实现检查点保存
-- 支持从任意批次恢复
-- 避免重复处理
-
-## 预期效果
-
-实施这些修复后:
-- ✅ **不会再卡住**: 超时后自动重试或跳过
-- ✅ **更清晰的进度**: 知道当前处理到哪个文档
-- ✅ **更好的容错性**: 单个文档失败不影响整体
-- ✅ **易于诊断**: 详细日志帮助快速定位问题
-
-## 性能影响
-
-- **正常情况**: 几乎无影响，只是多了日志输出
-- **超时情况**: 会重试，总时间略增加（但比卡住强）
-- **失败情况**: 跳过失败文档，整体速度更快
-
-## 下一步
-
-1. **立即**: 上传修复后的文件到Google Drive
-2. **测试**: 先用小数据集（5-10个文档）测试
-3. **运行**: 使用完整数据集，batch_size从小到大调整
-4. **监控**: 观察日志输出，记录任何异常
-5. **优化**: 根据实际情况调整timeout和batch_size
-
-## 联系信息
-
-如果问题仍然存在，请提供：
-- 完整的日志输出（特别是卡住前的最后几行）
-- 文档数量和批次大小
-- Ollama版本和模型名称
-- 系统资源使用情况（内存、GPU）
-
----
-
-**总结**: 问题已通过添加超时控制、重试机制和完善的异常处理得到解决。现在的代码能够优雅地处理LLM超时和失败，并提供详细的进度反馈。

DEPLOYMENT_GUIDE.md

@@ -1,440 +0,0 @@
-# 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的计算能力。

GRAPHRAG_GUIDE.md

@@ -1,401 +0,0 @@
-# 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

@@ -1,427 +0,0 @@
-# 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系统中，提供了从实体提取到智能查询的完整工作流。通过合理选择查询策略，可以显著提升复杂问题的回答质量。

GRAPHRAG_TROUBLESHOOTING.md

@@ -1,328 +0,0 @@
-# GraphRAG 故障排除指南
-
-## 问题：处理批次时卡住不动
-
-### 症状
-- 处理到第6个批次时，实体提取后程序卡住
-- 没有错误信息，只是停止响应
-- CPU/GPU使用率下降到0
-
-### 根本原因
-
-#### 1. **LLM超时问题** ⏱️
-- **原因**: Ollama服务可能在处理复杂请求时超时
-- **表现**: 请求挂起，没有响应也没有错误
-- **解决方案**: 已添加timeout参数和重试机制
-
-#### 2. **内存泄漏** 💾
-- **原因**: 多次LLM调用后，Ollama可能积累内存
-- **表现**: 响应变慢，最终完全停止
-- **解决方案**: 
-  ```bash
-  # 重启Ollama服务
-  pkill ollama
-  ollama serve
-  ```
-
-#### 3. **连接池耗尽** 🔌
-- **原因**: 太多并发请求，没有正确关闭连接
-- **表现**: 新请求无法建立连接
-- **解决方案**: 已添加重试延迟和异常处理
-
-#### 4. **文档内容过长** 📄
-- **原因**: 某些文档chunk可能超过LLM的上下文窗口
-- **表现**: LLM静默失败
-- **解决方案**: 已限制为2000字符
-
-## 已实施的修复
-
-### 1. 添加超时控制
-```python
-EntityExtractor(timeout=60, max_retries=3)
-```
-- 每次LLM调用最多60秒超时
-- 失败后最多重试3次
-- 重试间隔递增（2s, 4s, 6s）
-
-### 2. 改进的错误处理
-```python
-try:
-    result = extractor.extract_from_document(...)
-except Exception as e:
-    print(f"❌ 文档处理失败: {e}")
-    extraction_results.append({"entities": [], "relations": []})
-```
-- 捕获所有异常
-- 添加空结果而不是崩溃
-- 继续处理下一个文档
-
-### 3. 详细的进度日志
-```
-⚙️  === 批次 6/10 (文档 51-60) ===
-🔍 文档 #51: 开始提取...
-   🔄 提取实体 (尝试 1/3)... ✅ 提取到 5 个实体
-   🔄 提取关系 (尝试 1/3)... ✅ 提取到 3 个关系
-📊 文档 #51 完成: 5 实体, 3 关系
-```
-
-## 故障排除步骤
-
-### 步骤 1: 检查Ollama服务状态
-```bash
-# 检查Ollama是否运行
-ps aux | grep ollama
-
-# 查看Ollama日志
-tail -f ~/.ollama/logs/server.log
-
-# 检查模型是否加载
-ollama list
-```
-
-### 步骤 2: 检查系统资源
-```bash
-# 内存使用
-free -h  # Linux
-top      # 查看Ollama进程
-
-# 在Colab中
-!nvidia-smi  # GPU内存
-!ps aux | grep ollama
-```
-
-### 步骤 3: 减小批次大小
-```python
-# 在 main_graphrag.py 或调用代码中
-graph = indexer.index_documents(
-    documents=doc_splits,
-    batch_size=5,  # 从10降到5
-    save_path="./knowledge_graph.pkl"
-)
-```
-
-### 步骤 4: 测试单个文档
-```python
-# 测试提取器是否工作
-from entity_extractor import EntityExtractor
-
-extractor = EntityExtractor(timeout=30, max_retries=2)
-result = extractor.extract_from_document(
-    "测试文本...",
-    doc_index=0
-)
-print(result)
-```
-
-### 步骤 5: 重启Ollama服务
-```bash
-# 完全重启Ollama
-pkill -9 ollama
-sleep 2
-ollama serve &
-
-# 等待服务启动
-sleep 5
-
-# 验证服务
-curl http://localhost:11434/api/tags
-```
-
-## 性能优化建议
-
-### 1. 调整超时参数
-```python
-# 对于较慢的机器或GPU
-extractor = EntityExtractor(
-    timeout=120,      # 增加到2分钟
-    max_retries=5     # 更多重试次数
-)
-```
-
-### 2. 使用更小的模型
-```python
-# 在 config.py 中
-LOCAL_LLM = "mistral:7b"     # 默认
-# 改为
-LOCAL_LLM = "llama2:7b"      # 更快
-# 或
-LOCAL_LLM = "phi:latest"     # 最快，但质量较低
-```
-
-### 3. 增加批次间延迟
-```python
-# 在 graph_indexer.py 中，批次循环后添加
-import time
-for i in range(0, len(documents), batch_size):
-    # ... 处理批次 ...
-    time.sleep(2)  # 给Ollama 2秒恢复时间
-```
-
-### 4. 限制并发请求
-```python
-# 使用线程池控制并发
-from concurrent.futures import ThreadPoolExecutor
-
-with ThreadPoolExecutor(max_workers=2) as executor:
-    futures = [executor.submit(extract, doc) for doc in batch]
-    results = [f.result() for f in futures]
-```
-
-## 在Google Colab中的特殊问题
-
-### 问题: Colab会话超时
-**解决方案**: 使用checkpoint保存进度
-```python
-# 每处理N个批次保存一次
-if batch_num % 5 == 0:
-    checkpoint = {
-        'extraction_results': extraction_results,
-        'processed_docs': i + len(batch)
-    }
-    import pickle
-    with open(f'/content/drive/MyDrive/checkpoint_{batch_num}.pkl', 'wb') as f:
-        pickle.dump(checkpoint, f)
-```
-
-### 问题: Ollama内存不足
-**解决方案**: 在Colab中设置较小的上下文窗口
-```python
-# 启动Ollama时
-!OLLAMA_NUM_GPU=1 OLLAMA_MAX_LOADED_MODELS=1 ollama serve > /tmp/ollama.log 2>&1 &
-```
-
-## 监控和调试
-
-### 添加详细日志
-```python
-import logging
-
-logging.basicConfig(
-    level=logging.DEBUG,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.FileHandler('graphrag_debug.log'),
-        logging.StreamHandler()
-    ]
-)
-```
-
-### 使用超时上下文管理器
-```python
-import signal
-from contextlib import contextmanager
-
-@contextmanager
-def timeout(seconds):
-    def handler(signum, frame):
-        raise TimeoutError()
-    signal.signal(signal.SIGALRM, handler)
-    signal.alarm(seconds)
-    try:
-        yield
-    finally:
-        signal.alarm(0)
-
-# 使用
-with timeout(60):
-    result = extractor.extract_from_document(text)
-```
-
-## 常见错误信息
-
-| 错误信息 | 原因 | 解决方案 |
-|---------|------|---------|
-| `Connection refused` | Ollama未运行 | `ollama serve` |
-| `Timeout` | LLM响应慢 | 增加timeout参数 |
-| `CUDA out of memory` | GPU内存不足 | 减小batch_size |
-| `JSON decode error` | LLM输出格式错误 | 检查prompt模板 |
-| 卡住无输出 | LLM挂起 | 重启Ollama，添加超时 |
-
-## 快速修复清单
-
-✅ **立即尝试这些步骤**:
-
-1. **重启Ollama**
-   ```bash
-   pkill ollama && sleep 2 && ollama serve &
-   ```
-
-2. **减小批次大小**
-   ```python
-   batch_size=3  # 从10改为3
-   ```
-
-3. **增加超时时间**
-   ```python
-   EntityExtractor(timeout=120, max_retries=5)
-   ```
-
-4. **检查第6个文档**
-   ```python
-   # 单独处理第6个文档看是否有特殊问题
-   doc_6 = documents[5]
-   print(f"文档长度: {len(doc_6.page_content)}")
-   print(f"前500字符: {doc_6.page_content[:500]}")
-   ```
-
-5. **使用检查点恢复**
-   ```python
-   # 从第6批次重新开始
-   start_index = 50  # 跳过前5批次
-   documents_remaining = documents[start_index:]
-   ```
-
-## 预防措施
-
-1. **开始前验证环境**
-   ```bash
-   # 检查所有依赖
-   python colab_install_deps.py
-   
-   # 测试Ollama
-   ollama list
-   ollama run mistral "Hello"
-   ```
-
-2. **使用小数据集测试**
-   ```python
-   # 先用5个文档测试
-   test_docs = doc_splits[:5]
-   graph = indexer.index_documents(test_docs, batch_size=2)
-   ```
-
-3. **监控资源使用**
-   ```python
-   import psutil
-   print(f"内存使用: {psutil.virtual_memory().percent}%")
-   ```
-
-## 获取帮助
-
-如果问题持续，请提供以下信息：
-
-1. **系统信息**
-   - OS版本
-   - Python版本
-   - Ollama版本
-   - 可用内存/GPU
-
-2. **错误日志**
-   - 最后一条成功的输出
-   - 完整的错误堆栈
-   - Ollama日志 (`~/.ollama/logs/server.log`)
-
-3. **复现步骤**
-   - 文档数量
-   - batch_size
-   - 在哪个批次卡住
-
-## 总结
-
-**最可能的原因**: LLM调用超时或Ollama内存积累
-
-**最快的解决方案**:
-1. 重启Ollama服务
-2. 减小batch_size到3-5
-3. 使用更新后的带超时和重试的代码
-
-现在的代码已经包含了所有这些保护措施，应该能够稳定运行！

KAGGLE_DATASET_GUIDE.md

@@ -1,478 +0,0 @@
-# Kaggle Ollama Dataset 保存与加载指南
-
-## 📋 目录
-1. [问题背景](#问题背景)
-2. [解决方案](#解决方案)
-3. [详细步骤](#详细步骤)
-4. [时间对比](#时间对比)
-5. [故障排除](#故障排除)
-
----
-
-## 问题背景
-
-### Kaggle 存储特性
-
-在 Kaggle 环境中：
-
-| 目录 | 会话结束后 | 说明 |
-|------|----------|------|
-| `/usr/local` | ❌ 删除 | Ollama 安装位置 |
-| `/kaggle/working` | ❌ 删除 | 工作目录 |
-| `/home` | ❌ 删除 | 用户目录（模型存储位置） |
-| `/kaggle/input` | ✅ 保留 | **Dataset 目录（永久）** |
-
-### 当前问题
-
-每次启动 Kaggle Notebook 都需要：
-1. 下载 Ollama 安装脚本（~100MB）
-2. 安装 Ollama
-3. 下载模型（Mistral 4GB，需要 5-10 分钟）
-
-**总耗时：约 10-15 分钟**
-
----
-
-## 解决方案
-
-### 核心思路
-
-将 Ollama 和模型**一次性**保存到 Kaggle Dataset（永久存储），后续每次启动直接加载。
-
-### 优势
-
-- ✅ **只需上传一次**：将 Ollama 和模型保存为 Dataset
-- ✅ **秒级加载**：后续启动只需 10-30 秒
-- ✅ **节省时间**：每次节省 10+ 分钟
-- ✅ **稳定可靠**：不受网络影响
-
----
-
-## 详细步骤
-
-### 阶段 1: 首次备份（一次性工作）
-
-#### 1.1 在 Kaggle Notebook 中准备环境
-
-```python
-# 1. 克隆项目
-!git clone https://github.com/你的用户名/adaptive_RAG.git
-%cd adaptive_RAG
-
-# 2. 安装 Ollama
-!curl -fsSL https://ollama.com/install.sh | sh
-
-# 3. 启动 Ollama 服务（后台运行）
-import subprocess
-subprocess.Popen(['ollama', 'serve'])
-
-# 4. 等待服务启动
-import time
-time.sleep(15)
-
-# 5. 下载模型
-!ollama pull mistral  # 或 phi, tinyllama 等
-```
-
-#### 1.2 运行备份脚本
-
-```python
-# 执行备份脚本
-exec(open('KAGGLE_SAVE_OLLAMA.py').read())
-```
-
-**输出示例：**
-```
-====================================================================
-💾 Kaggle Ollama 保存工具
-====================================================================
-
-📋 配置:
-   模型: mistral
-   输出目录: /kaggle/working/ollama_backup
-
-📁 步骤 1/4: 创建备份目录...
-   ✅ 目录创建成功
-
-📦 步骤 2/4: 备份 Ollama 二进制文件...
-   找到 Ollama: /usr/local/bin/ollama
-   ✅ Ollama 二进制文件已备份
-
-🤖 步骤 3/4: 备份 mistral 模型...
-   找到模型目录: /root/.ollama/models
-   模型总大小: 4.12 GB
-   📦 创建压缩包（这可能需要几分钟）...
-   ✅ 压缩完成
-      耗时: 180秒
-      压缩包大小: 4.10 GB
-
-📝 步骤 4/4: 生成说明文件...
-   ✅ 说明文件已生成
-
-📊 备份内容:
-   • ollama: 0.05 GB
-   • ollama_models.tar.gz: 4.10 GB
-   • README.md: 0.00 MB
-
-====================================================================
-✅ 备份完成！
-====================================================================
-```
-
-#### 1.3 下载备份文件
-
-在 Kaggle Notebook 右侧：
-1. 点击 **Output** 标签
-2. 找到 `ollama_backup` 目录
-3. 点击下载按钮
-4. 等待下载完成（约 4GB，取决于网络速度）
-
-#### 1.4 创建 Kaggle Dataset
-
-1. **访问 Kaggle Datasets 页面**
-   - 打开：https://www.kaggle.com/datasets
-   - 点击右上角 **"New Dataset"** 按钮
-
-2. **上传文件**
-   - 将下载的两个文件拖拽上传：
-     - `ollama` (二进制文件，约 50MB)
-     - `ollama_models.tar.gz` (模型压缩包，约 4GB)
-   
-3. **配置 Dataset**
-   - **Title**: `ollama-mistral-backup`（或其他名称）
-   - **Subtitle**: "Ollama with Mistral model for quick loading"
-   - **Visibility**: **Private**（避免占用公开配额）
-   - **License**: 选择合适的开源协议
-
-4. **创建**
-   - 点击 **"Create"** 按钮
-   - 等待上传完成（4GB 大约需要 10-30 分钟，取决于网络）
-
----
-
-### 阶段 2: 后续使用（每次启动）
-
-#### 2.1 添加 Dataset 到 Notebook
-
-在 Kaggle Notebook 中：
-1. 点击右侧 **"Add data"** 按钮
-2. 选择 **"Your Datasets"** 标签
-3. 搜索并选择你的 `ollama-mistral-backup`
-4. 点击 **"Add"** 按钮
-
-#### 2.2 克隆项目
-
-```python
-# 在第一个单元格
-import os
-os.chdir('/kaggle/working')
-
-!git clone https://github.com/你的用户名/adaptive_RAG.git
-%cd adaptive_RAG
-```
-
-#### 2.3 加载 Ollama
-
-```python
-# 在第二个单元格
-exec(open('KAGGLE_LOAD_OLLAMA.py').read())
-```
-
-**输出示例：**
-```
-====================================================================
-📦 从 Dataset 加载 Ollama（快速启动）
-====================================================================
-
-📋 配置:
-   Dataset 路径: /kaggle/input/ollama-mistral-backup
-
-🔍 步骤 1/5: 检查 Dataset...
-   ✅ Dataset 存在
-
-   Dataset 内容:
-      • ollama: 0.05 GB
-      • ollama_models.tar.gz: 4.10 GB
-
-🔧 步骤 2/5: 安装 Ollama 二进制文件...
-   ✅ Ollama 已安装到: /usr/local/bin/ollama
-   📌 ollama version 0.1.x
-
-📦 步骤 3/5: 解压模型文件...
-   找到模型压缩包: 4.10 GB
-   📦 开始解压（这可能需要 10-30 秒）...
-   ✅ 解压完成（耗时: 25秒）
-   📊 模型总大小: 4.12 GB
-
-🚀 步骤 4/5: 启动 Ollama 服务...
-   🔄 启动服务...
-   ⏳ 等待服务启动（15秒）...
-   ✅ Ollama 服务运行正常
-
-✅ 步骤 5/5: 验证模型...
-
-   可用模型:
-   NAME        ID              SIZE    MODIFIED
-   mistral:latest  xxx         4.1 GB  2 minutes ago
-
-====================================================================
-✅ Ollama 加载完成！
-====================================================================
-
-📊 加载总结:
-   • Ollama 服务: ✅ 运行中
-   • 模型: ✅ 已加载
-   • 总耗时: < 1 分钟
-
-💡 对比:
-   • 传统方式: 5-10 分钟（重新下载）
-   • Dataset 方式: < 1 分钟（直接加载）
-   • 节省时间: 约 90%！
-```
-
-#### 2.4 开始使用
-
-```python
-# 在第三个单元格
-from document_processor import DocumentProcessor
-from graph_indexer import GraphRAGIndexer
-
-# 加载文档
-processor = DocumentProcessor()
-vectorstore, retriever, doc_splits = processor.setup_knowledge_base(enable_graphrag=True)
-
-# 使用异步索引（速度快）
-indexer = GraphRAGIndexer(async_batch_size=8)
-graph = indexer.index_documents(doc_splits)
-```
-
----
-
-## 时间对比
-
-### 传统方式（每次启动）
-
-| 步骤 | 耗时 |
-|------|------|
-| 下载安装脚本 | 30秒 |
-| 安装 Ollama | 1分钟 |
-| 下载 Mistral 模型 | 5-10分钟 |
-| 启动服务 | 15秒 |
-| **总计** | **约 10-15 分钟** |
-
-### Dataset 方式（每次启动）
-
-| 步骤 | 耗时 |
-|------|------|
-| 加载 Dataset（自动） | 0秒 |
-| 复制 Ollama 二进制 | 2秒 |
-| 解压模型文件 | 20-30秒 |
-| 启动服务 | 15秒 |
-| **总计** | **约 40-50 秒** |
-
-### 节省时间
-
-- ✅ 首次上传：30 分钟（一次性工作）
-- ✅ 后续每次：节省 **10+ 分钟**
-- ✅ 运行 10 次后：累计节省 **100+ 分钟**
-
----
-
-## 不同模型的大小对比
-
-| 模型 | 原始大小 | 压缩后大小 | 下载时间 | 解压时间 |
-|------|----------|-----------|----------|----------|
-| qwen:0.5b | 350MB | ~300MB | 30秒 | 5秒 |
-| tinyllama | 600MB | ~550MB | 1分钟 | 8秒 |
-| phi | 1.6GB | ~1.5GB | 2-3分钟 | 15秒 |
-| mistral | 4GB | ~4GB | 5-10分钟 | 25秒 |
-| llama2:7b | 3.8GB | ~3.8GB | 5-10分钟 | 25秒 |
-
-### 推荐选择
-
-- **开发测试**：phi（平衡速度和质量）
-- **快速验证**：tinyllama（最快）
-- **最佳质量**：mistral（如果网络好）
-
----
-
-## 故障排除
-
-### 问题 1: Dataset 不存在
-
-**症状：**
-```
-❌ Dataset 不存在: /kaggle/input/ollama-mistral-backup
-```
-
-**解决方案：**
-1. 检查 Dataset 是否已添加到 Notebook
-2. 检查 Dataset 名称是否正确
-3. 修改 `KAGGLE_LOAD_OLLAMA.py` 中的 `DATASET_NAME`
-
-### 问题 2: 上传 Dataset 失败
-
-**症状：**
-上传时卡住或失败
-
-**解决方案：**
-1. 检查网络连接
-2. 使用更小的模型（如 phi 或 tinyllama）
-3. 分多次尝试上传
-
-### 问题 3: Ollama 无法运行
-
-**症状：**
-```
-ollama: command not found
-```
-
-**解决方案：**
-```bash
-# 检查文件权限
-chmod +x /usr/local/bin/ollama
-
-# 验证安装
-ollama --version
-```
-
-### 问题 4: 模型列表为空
-
-**症状：**
-```
-ollama list
-# 输出为空
-```
-
-**解决方案：**
-```python
-# 检查模型目录
-import os
-models_dir = os.path.expanduser("~/.ollama/models")
-print(os.listdir(models_dir))
-
-# 重新解压模型
-# 重新运行 KAGGLE_LOAD_OLLAMA.py
-```
-
-### 问题 5: Dataset 超过大小限制
-
-**症状：**
-上传时提示 Dataset 过大
-
-**解决方案：**
-1. Kaggle 免费用户每个 Dataset 限制 20GB
-2. 使用更小的模型
-3. 或考虑升级为 Kaggle 专业版
-
----
-
-## 高级优化
-
-### 1. 多模型备份
-
-如果想备份多个模型：
-
-```bash
-# 修改 KAGGLE_SAVE_OLLAMA.py
-# 在下载模型步骤添加：
-!ollama pull phi
-!ollama pull tinyllama
-!ollama pull mistral
-
-# 然后运行备份脚本
-# 所有模型会一起打包
-```
-
-### 2. 使用更快的压缩
-
-```python
-# 修改压缩命令（牺牲压缩率换取速度）
-# 在 KAGGLE_SAVE_OLLAMA.py 中修改：
-with tarfile.open(models_archive, 'w') as tar:  # 去掉 :gz
-    tar.add(ollama_models_dir, arcname='models')
-```
-
-### 3. 增量更新
-
-如果模型有更新：
-1. 在 Kaggle Notebook 中下载新模型
-2. 重新运行 `KAGGLE_SAVE_OLLAMA.py`
-3. 下载新的压缩包
-4. 更新 Dataset（覆盖旧文件）
-
----
-
-## 完整工作流示例
-
-### 第一次使用（约 45 分钟）
-
-```python
-# === Notebook Cell 1: 准备环境 ===
-!git clone https://github.com/你的用户名/adaptive_RAG.git
-%cd adaptive_RAG
-
-# === Notebook Cell 2: 安装 Ollama ===
-!curl -fsSL https://ollama.com/install.sh | sh
-
-# === Notebook Cell 3: 启动服务 ===
-import subprocess, time
-subprocess.Popen(['ollama', 'serve'])
-time.sleep(15)
-
-# === Notebook Cell 4: 下载模型 ===
-!ollama pull mistral  # 5-10 分钟
-
-# === Notebook Cell 5: 备份 ===
-exec(open('KAGGLE_SAVE_OLLAMA.py').read())  # 3-5 分钟
-
-# === 然后手动：===
-# 1. 下载 ollama_backup 目录（5-15 分钟）
-# 2. 创建 Kaggle Dataset 上传（10-30 分钟）
-```
-
-### 后续使用（约 2 分钟）
-
-```python
-# === Notebook Cell 1: 克隆项目 ===
-%cd /kaggle/working
-!git clone https://github.com/你的用户名/adaptive_RAG.git
-%cd adaptive_RAG
-
-# === Notebook Cell 2: 加载 Ollama ===
-exec(open('KAGGLE_LOAD_OLLAMA.py').read())  # 40-50 秒
-
-# === Notebook Cell 3: 开始工作 ===
-from document_processor import DocumentProcessor
-from graph_indexer import GraphRAGIndexer
-
-processor = DocumentProcessor()
-vectorstore, retriever, doc_splits = processor.setup_knowledge_base(enable_graphrag=True)
-
-indexer = GraphRAGIndexer(async_batch_size=8)
-graph = indexer.index_documents(doc_splits)
-```
-
----
-
-## 总结
-
-### ✅ 优势
-- 一次性上传，永久使用
-- 每次启动节省 10+ 分钟
-- 不受网络波动影响
-- 稳定可靠
-
-### ⚠️ 注意事项
-- 首次上传需要时间和网络
-- Dataset 有大小限制（20GB）
-- 需要手动管理 Dataset
-
-### 💡 建议
-- **强烈推荐**用于频繁使用 Kaggle 的场景
-- 选择合适大小的模型（推荐 phi）
-- 保持 Dataset 为 Private 避免占用配额
-
----
-
-**祝使用愉快！🎉**

KAGGLE_INIT.py

@@ -1,148 +0,0 @@
-"""
-Kaggle 会话初始化脚本
-解决 Stop Session 后项目丢失的问题
-
-使用方法：
-在 Kaggle Notebook 第一个单元格运行：
-    exec(open('/kaggle/input/your-dataset/KAGGLE_INIT.py').read())
-或者直接复制此脚本内容到第一个单元格
-"""
-
-import os
-import subprocess
-import sys
-from pathlib import Path
-
-print("🚀 Kaggle 会话自动初始化")
-print("="*70)
-
-# ==================== 配置区域 ====================
-REPO_URL = "https://github.com/LannyCodes/adaptive_RAG.git"
-PROJECT_DIR = "/kaggle/working/adaptive_RAG"
-PREVIOUS_RUN_INPUT = "/kaggle/input/output"  # 👈 修改为您保存的 Dataset 名称
-
-# ==================== 1. 检查并克隆项目 ====================
-print("\n📦 步骤 1: 检查项目状态...")
-
-if os.path.exists(PROJECT_DIR):
-    print(f"   ✅ 项目已存在: {PROJECT_DIR}")
-    print("   ℹ️ 如需更新代码，请运行:")
-    print(f"      cd {PROJECT_DIR} && git pull origin main")
-else:
-    print(f"   📥 项目不存在，开始克隆...")
-    
-    os.chdir('/kaggle/working')
-    
-    result = subprocess.run(
-        ['git', 'clone', REPO_URL],
-        capture_output=True,
-        text=True
-    )
-    
-    if result.returncode == 0:
-        print(f"   ✅ 项目克隆成功")
-    else:
-        print(f"   ❌ 克隆失败:")
-        print(f"      {result.stderr}")
-        print("\n   💡 可能的原因:")
-        print("      1. 网络问题")
-        print("      2. 仓库地址错误")
-        print("      3. 仓库是私有的（需要认证）")
-        sys.exit(1)
-
-# ==================== 2. 恢复之前的数据 ====================
-print("\n💾 步骤 2: 检查之前的运行数据...")
-
-if os.path.exists(PREVIOUS_RUN_INPUT):
-    print(f"   ✅ 发现之前的数据: {PREVIOUS_RUN_INPUT}")
-    
-    # 列出可恢复的文件
-    saved_files = list(Path(PREVIOUS_RUN_INPUT).glob('*'))
-    
-    if saved_files:
-        print(f"   📂 可恢复的文件:")
-        for file in saved_files[:10]:  # 只显示前10个
-            print(f"      • {file.name}")
-        
-        # 恢复知识图谱（如果存在）
-        kg_file = Path(PREVIOUS_RUN_INPUT) / 'knowledge_graph.pkl'
-        if kg_file.exists():
-            import shutil
-            dest = Path(PROJECT_DIR) / 'knowledge_graph.pkl'
-            shutil.copy2(kg_file, dest)
-            print(f"   ✅ 已恢复知识图谱")
-        
-        print(f"\n   💡 如需恢复其他文件，使用:")
-        print(f"      import shutil")
-        print(f"      shutil.copy2('{PREVIOUS_RUN_INPUT}/文件名', '{PROJECT_DIR}/文件名')")
-    else:
-        print("   ⚠️ 数据目录为空")
-else:
-    print("   ℹ️ 未发现之前的运行数据（首次运行）")
-    print(f"   💡 会话结束时，将 /kaggle/working 保存为 Dataset")
-    print(f"      命名为: output")
-
-# ==================== 3. 设置工作环境 ====================
-print("\n⚙️ 步骤 3: 设置工作环境...")
-
-# 进入项目目录
-os.chdir(PROJECT_DIR)
-
-# 添加到 Python 路径
-if PROJECT_DIR not in sys.path:
-    sys.path.insert(0, PROJECT_DIR)
-
-print(f"   ✅ 当前目录: {os.getcwd()}")
-print(f"   ✅ Python 路径已更新")
-
-# ==================== 4. 显示系统信息 ====================
-print("\n📊 步骤 4: 系统信息...")
-
-# Python 版本
-print(f"   • Python: {sys.version.split()[0]}")
-
-# GPU 状态
-gpu_check = subprocess.run(['nvidia-smi'], capture_output=True, text=True)
-if gpu_check.returncode == 0:
-    # 提取 GPU 信息
-    for line in gpu_check.stdout.split('\n'):
-        if 'Tesla' in line or 'P100' in line or 'T4' in line:
-            print(f"   • GPU: {line.strip()}")
-            break
-else:
-    print("   • GPU: 不可用")
-
-# 磁盘空间
-disk_check = subprocess.run(['df', '-h', '/kaggle/working'], capture_output=True, text=True)
-if disk_check.returncode == 0:
-    lines = disk_check.stdout.strip().split('\n')
-    if len(lines) > 1:
-        info = lines[1].split()
-        print(f"   • 可用空间: {info[3]}")
-
-# ==================== 5. 快速测试 ====================
-print("\n🧪 步骤 5: 快速测试...")
-
-# 检查关键文件
-key_files = [
-    'entity_extractor.py',
-    'graph_indexer.py',
-    'knowledge_graph.py',
-    'config.py'
-]
-
-all_files_exist = True
-for file in key_files:
-    if os.path.exists(file):
-        print(f"   ✅ {file}")
-    else:
-        print(f"   ❌ {file} 缺失")
-        all_files_exist = False
-
-if not all_files_exist:
-    print("\n   ⚠️ 部分关键文件缺失，请检查仓库")
-
-# ==================== 完成 ====================
-print("\n" + "="*70)
-print("✅ 初始化完成！")
-print("="*70)

KAGGLE_OLLAMA_PERSISTENCE.md

@@ -1,404 +0,0 @@
-# Kaggle Ollama 持久化方案
-
-## 🎯 问题
-
-在 Kaggle 上每次会话结束后：
-- ❌ Ollama 安装被删除（位于 `/usr/local/bin/`）
-- ❌ 模型被删除（位于 `~/.ollama/`）
-- ❌ 每次重启需要 10-15 分钟重新下载
-
-## ✅ 解决方案
-
-将 Ollama 和模型保存到 **Kaggle Dataset**（永久存储），后续加载只需 40-50 秒。
-
----
-
-## 📋 完整流程
-
-### 阶段 1: 首次备份（一次性，约 30-60 分钟）
-
-#### 步骤 1: 在 Kaggle Notebook 中准备
-
-```python
-# Cell 1: 克隆项目
-import os
-os.chdir('/kaggle/working')
-!git clone https://github.com/你的用户名/adaptive_RAG.git
-%cd adaptive_RAG
-
-# Cell 2: 安装 Ollama
-!curl -fsSL https://ollama.com/install.sh | sh
-
-# Cell 3: 启动服务
-import subprocess
-import time
-subprocess.Popen(['ollama', 'serve'])
-time.sleep(15)
-
-# Cell 4: 下载模型
-!ollama pull mistral  # 或 phi, tinyllama
-
-# Cell 5: 验证环境（可选但推荐）
-exec(open('KAGGLE_CHECK_OLLAMA.py').read())
-```
-
-#### 步骤 2: 运行备份脚本
-
-```python
-# Cell 6: 执行备份
-exec(open('KAGGLE_SAVE_OLLAMA.py').read())
-```
-
-**输出示例：**
-```
-====================================================================
-💾 Kaggle Ollama 保存工具
-====================================================================
-
-📋 配置:
-   模型: mistral
-   输出目录: /kaggle/working/ollama_backup
-
-📁 步骤 1/4: 创建备份目录...
-   ✅ 目录创建成功
-
-📦 步骤 2/4: 备份 Ollama 二进制文件...
-   找到 Ollama: /usr/local/bin/ollama
-   ✅ Ollama 二进制文件已备份
-
-🤖 步骤 3/4: 备份 mistral 模型...
-   找到模型目录: /root/.ollama
-   模型总大小: 4.12 GB
-   📦 创建压缩包（这可能需要几分钟）...
-   正在压缩: /root/.ollama
-   ✅ 压缩完成
-      耗时: 180秒
-      压缩包大小: 4.10 GB
-
-📝 步骤 4/4: 生成说明文件...
-   ✅ 说明文件已生成
-
-====================================================================
-✅ 备份完成！
-====================================================================
-```
-
-#### 步骤 3: 下载备份文件
-
-1. 在 Kaggle Notebook 右侧点击 **"Output"** 标签
-2. 找到 `ollama_backup` 目录
-3. 点击下载（约 4GB，需要 5-15 分钟取决于网络）
-
-#### 步骤 4: 创建 Kaggle Dataset
-
-1. **访问 Kaggle Datasets**
-   - URL: https://www.kaggle.com/datasets
-   - 点击 **"New Dataset"**
-
-2. **上传文件**
-   - 拖拽或选择：
-     - `ollama` (约 50MB)
-     - `ollama_models.tar.gz` (约 4GB)
-
-3. **配置 Dataset**
-   - **Title**: `ollama-mistral-backup`
-   - **Visibility**: Private
-   - 点击 **"Create"**
-
-4. **等待上传**
-   - 约 10-30 分钟（取决于网络）
-
----
-
-### 阶段 2: 后续使用（每次约 1-2 分钟）
-
-#### 步骤 1: 新建 Notebook
-
-1. 添加 Dataset
-   - 点击右侧 **"Add data"**
-   - 选择 **"Your Datasets"**
-   - 搜索 `ollama-mistral-backup`
-   - 点击 **"Add"**
-
-#### 步骤 2: 克隆项目并加载 Ollama
-
-```python
-# Cell 1: 克隆项目
-import os
-os.chdir('/kaggle/working')
-!git clone https://github.com/你的用户名/adaptive_RAG.git
-%cd adaptive_RAG
-
-# Cell 2: 加载 Ollama（快速！）
-exec(open('KAGGLE_LOAD_OLLAMA.py').read())
-```
-
-**输出示例：**
-```
-====================================================================
-📦 从 Dataset 加载 Ollama（快速启动）
-====================================================================
-
-📋 配置:
-   Dataset 路径: /kaggle/input/ollama-mistral-backup
-
-🔍 步骤 1/5: 检查 Dataset...
-   ✅ Dataset 存在
-
-🔧 步骤 2/5: 安装 Ollama 二进制文件...
-   ✅ Ollama 已安装到: /usr/local/bin/ollama
-   📌 ollama version 0.1.x
-
-📦 步骤 3/5: 解压模型文件...
-   找到模型压缩包: 4.10 GB
-   📦 开始解压（这可能需要 10-30 秒）...
-   ✅ 解压完成（耗时: 25秒）
-   📊 模型总大小: 4.12 GB
-
-🚀 步骤 4/5: 启动 Ollama 服务...
-   🔄 启动服务...
-   ⏳ 等待服务启动（15秒）...
-   ✅ Ollama 服务运行正常
-
-✅ 步骤 5/5: 验证模型...
-   可用模型:
-   NAME            ID          SIZE    MODIFIED
-   mistral:latest  xxx         4.1 GB  2 minutes ago
-
-====================================================================
-✅ Ollama 加载完成！
-====================================================================
-
-📊 加载总结:
-   • Ollama 服务: ✅ 运行中
-   • 模型: ✅ 已加载
-   • 总耗时: < 1 分钟
-```
-
-#### 步骤 3: 开始使用
-
-```python
-# Cell 3: 运行你的 GraphRAG 项目
-from document_processor import DocumentProcessor
-from graph_indexer import GraphRAGIndexer
-
-processor = DocumentProcessor()
-vectorstore, retriever, doc_splits = processor.setup_knowledge_base(enable_graphrag=True)
-
-indexer = GraphRAGIndexer(async_batch_size=8)
-graph = indexer.index_documents(doc_splits)
-```
-
----
-
-## ⏱️ 时间对比
-
-### 传统方式（每���启动）
-
-| 步骤 | 时间 |
-|------|------|
-| 下载安装脚本 | 30秒 |
-| 安装 Ollama | 1分钟 |
-| 下载 Mistral | 5-10分钟 |
-| 启动服务 | 15秒 |
-| **总计** | **10-15分钟** ❌ |
-
-### Dataset 方式（每次启动）
-
-| 步骤 | 时间 |
-|------|------|
-| 复制二进制 | 2秒 |
-| 解压模型 | 25秒 |
-| 启动服务 | 15秒 |
-| **总计** | **40-50秒** ✅ |
-
-### 收益分析
-
-- **首次投入**：30-60 分钟（一次性）
-- **每次节省**：10+ 分钟
-- **运行 5 次回本**：5 × 10 = 50 分钟 > 30 分钟
-- **运行 10 次后**：累计节省 **100+ 分钟**！
-
----
-
-## 🔍 验证脚本
-
-在备份前建议运行验证脚本，确保环境正确：
-
-```python
-# 检查 Ollama 安装和模型位置
-exec(open('KAGGLE_CHECK_OLLAMA.py').read())
-```
-
-**该脚本会检查：**
-- ✅ Ollama 安装位置
-- ✅ Ollama 服务状态
-- ✅ 模型存储目录
-- ✅ 已下载的模型列表
-- ✅ 推荐备份方案
-
----
-
-## 📊 不同模型的对比
-
-| 模型 | 原始大小 | 压缩后 | 下载时间 | 解压时间 | 推荐度 |
-|------|----------|--------|----------|----------|--------|
-| qwen:0.5b | 350MB | ~300MB | 30秒 | 5秒 | ⭐⭐ 快但质量低 |
-| tinyllama | 600MB | ~550MB | 1分钟 | 8秒 | ⭐⭐⭐ 快速测试 |
-| phi | 1.6GB | ~1.5GB | 2-3分钟 | 15秒 | ⭐⭐⭐⭐ **推荐** |
-| mistral | 4GB | ~4GB | 5-10分钟 | 25秒 | ⭐⭐⭐⭐⭐ 质量最好 |
-
-**建议：**
-- 开发测试：使用 `phi`（平衡）
-- 快速验证：使用 `tinyllama`
-- 生产环境：使用 `mistral`
-
----
-
-## ❓ 常见问题
-
-### Q1: 脚本是否正确？
-
-**A**: 是的，已修正。脚本会：
-- ✅ 自动查找 Ollama 安装位置（`/usr/local/bin/ollama`）
-- ✅ 自动查找模型目录（`~/.ollama` 或 `/root/.ollama`）
-- ✅ 完整备份整个 `.ollama` 目录（包括 models, manifests 等）
-- ✅ 正确解压到 `~/.ollama`
-
-### Q2: Dataset 名称可以改吗？
-
-**A**: 可以！修改 `KAGGLE_LOAD_OLLAMA.py` 中的：
-```python
-DATASET_NAME = "你的Dataset名称"  # 第18行
-```
-
-### Q3: 上传失败怎么办？
-
-**A**: 可能原因：
-1. 网络不稳定 → 重试或使用稳定网络
-2. 文件太大 → 使用更小的模型（如 phi）
-3. 浏览器问题 → 尝试更换浏览器
-
-### Q4: 可以备份多个模型吗？
-
-**A**: 可以！在备份前下载多个模型：
-```python
-!ollama pull phi
-!ollama pull tinyllama
-!ollama pull mistral
-# 然后运行备份脚本，会一起打包
-```
-
-### Q5: Dataset 有大小限制吗？
-
-**A**: 是的
-- 免费用户：每个 Dataset ≤ 20GB
-- Kaggle 专业版：更大限额
-
----
-
-## 🎯 最佳实践
-
-### ✅ 推荐做法
-
-1. **使用较小模型**：首选 `phi`（1.6GB）
-2. **验证后再备份**：运行 `KAGGLE_CHECK_OLLAMA.py`
-3. **Dataset 设为 Private**：避免占用公开配额
-4. **定期更新**：模型有更新时重新备份
-
-### ⚠️ 注意事项
-
-1. **首次上传需要时间**：计划好 30-60 分钟
-2. **网络稳定性**：确保上传期间网络稳定
-3. **Dataset 管理**：定期清理不用的 Datasets
-4. **备份验证**：首次加载后测试模型是否正常
-
----
-
-## 📝 完整示例
-
-### 首次使用（Kaggle Notebook）
-
-```python
-# ========== Cell 1: 环境准备 ==========
-import os
-os.chdir('/kaggle/working')
-!git clone https://github.com/你的仓库/adaptive_RAG.git
-%cd adaptive_RAG
-
-# ========== Cell 2: 安装 Ollama ==========
-!curl -fsSL https://ollama.com/install.sh | sh
-
-# ========== Cell 3: 启动服务 ==========
-import subprocess, time
-subprocess.Popen(['ollama', 'serve'])
-time.sleep(15)
-
-# ========== Cell 4: 下载模型 ==========
-!ollama pull phi  # 推荐使用 phi
-
-# ========== Cell 5: 验证环境 ==========
-exec(open('KAGGLE_CHECK_OLLAMA.py').read())
-
-# ========== Cell 6: 备份 ==========
-exec(open('KAGGLE_SAVE_OLLAMA.py').read())
-
-# ========== 手动操作 ==========
-# 1. 在右侧 Output 下载 ollama_backup
-# 2. 访问 kaggle.com/datasets 创建 Dataset
-# 3. 上传 ollama 和 ollama_models.tar.gz
-```
-
-### 后续使用（每次新 Notebook）
-
-```python
-# ========== Cell 1: 克隆项目 ==========
-import os
-os.chdir('/kaggle/working')
-!git clone https://github.com/你的仓库/adaptive_RAG.git
-%cd adaptive_RAG
-
-# ========== Cell 2: 快速加载 ==========
-# 注意：需要先在右侧 Add data 添加你的 Dataset
-exec(open('KAGGLE_LOAD_OLLAMA.py').read())
-
-# ========== Cell 3: 开始工作 ==========
-from graph_indexer import GraphRAGIndexer
-from document_processor import DocumentProcessor
-
-processor = DocumentProcessor()
-vectorstore, retriever, doc_splits = processor.setup_knowledge_base(enable_graphrag=True)
-
-indexer = GraphRAGIndexer(async_batch_size=8)
-graph = indexer.index_documents(doc_splits)
-
-print("✅ 一切就绪！开始使用 GraphRAG！")
-```
-
----
-
-## 🎉 总结
-
-### ✅ 优势
-- **大幅节省时间**：每次启动从 10-15 分钟 → 40-50 秒
-- **稳定可靠**：不受网络波动���响
-- **一次投入**：首次 30-60 分钟，之后永久受益
-- **易于使用**：两个脚本自动化全流程
-
-### 📈 投资回报
-- 首次投入：30-60 分钟
-- 每次节省：10+ 分钟
-- 5 次使用后回本
-- 长期收益：**节省数小时**
-
-### 💡 强烈推荐
-如果你经常使用 Kaggle 运行这个项目，**强烈建议**使用这个方案！
-
----
-
-**祝使用愉快！🚀**
-
-有问题请参考：
-- 验证脚本：`KAGGLE_CHECK_OLLAMA.py`
-- 备份脚本：`KAGGLE_SAVE_OLLAMA.py`
-- 加载脚本：`KAGGLE_LOAD_OLLAMA.py`

KAGGLE_OPTIMIZATION_GUIDE.md

@@ -1,367 +0,0 @@
-# Kaggle 环境优化指南 - 避免重复下载模型
-
-## 🚨 问题
-
-每次 Kaggle 会话重启后，Ollama 模型需要重新下载，Mistral 模型约 4GB，非常耗时。
-
-## 💡 解决方案
-
-### 方案 1: 使用更小的模型（推荐⭐⭐⭐⭐⭐）
-
-**最佳选择**：不需要修改代码，只需在下载模型时选择更小的版本。
-
-#### 可选模型对比
-
-| 模型 | 大小 | 下载时间 | 质量 | 推荐场景 |
-|-----|------|---------|------|---------|
-| `mistral` | ~4GB | 5-10分钟 | ⭐⭐⭐⭐⭐ | 本地开发 |
-| `phi` | ~1.6GB | 2-3分钟 | ⭐⭐⭐⭐ | **Kaggle推荐** |
-| `tinyllama` | ~600MB | 1分钟 | ⭐⭐⭐ | 快速测试 |
-| `qwen:0.5b` | ~350MB | 30秒 | ⭐⭐ | 极速测试 |
-
-#### 使用方法
-
-**选项 A**: 修改 `config.py`
-```python
-# 在 /kaggle/working/adaptive_RAG/config.py 中
-LOCAL_LLM = "phi"  # 👈 改为 phi 或 tinyllama
-```
-
-**选项 B**: 运行时覆盖（不修改代码）
-```python
-# 在 Kaggle Notebook 中
-import os
-os.environ['LOCAL_LLM_OVERRIDE'] = 'phi'
-
-# 然后正常导入
-from config import LOCAL_LLM
-# LOCAL_LLM 会自动使用 'phi'
-```
-
-**选项 C**: 直接在下载时指定
-```python
-# 下载更小的模型
-!ollama pull phi  # 代替 mistral
-
-# 或者
-!ollama pull tinyllama
-```
-
----
-
-### 方案 2: 持久化模型到 Kaggle Dataset（中等推荐⭐⭐⭐）
-
-将下载好的模型保存为 Dataset，下次会话直接加载。
-
-#### 步骤
-
-**会话 1（首次）：**
-```python
-import subprocess
-import shutil
-import os
-
-# 1. 下载模型
-subprocess.run(['ollama', 'pull', 'phi'])
-
-# 2. 找到模型存储位置
-# Ollama 模型通常存储在 ~/.ollama/models
-ollama_models = os.path.expanduser('~/.ollama/models')
-
-# 3. 复制到工作目录（会被保存为输出）
-if os.path.exists(ollama_models):
-    shutil.copytree(
-        ollama_models,
-        '/kaggle/working/ollama_models',
-        dirs_exist_ok=True
-    )
-    print("✅ 模型已复制到 /kaggle/working/ollama_models")
-    print("📌 会话结束后，将此目录保存为 Dataset")
-
-# 4. 会话结束时：Save Version → Save as Dataset
-#    命名为: ollama-models-cache
-```
-
-**会话 2（后续）：**
-```python
-import shutil
-import os
-
-# 1. 从 Dataset 恢复模型
-models_cache = '/kaggle/input/ollama-models-cache'
-
-if os.path.exists(models_cache):
-    print("📥 恢复 Ollama 模型...")
-    
-    # 创建 Ollama 模型目录
-    ollama_dir = os.path.expanduser('~/.ollama/models')
-    os.makedirs(ollama_dir, exist_ok=True)
-    
-    # 复制模型文件
-    shutil.copytree(
-        models_cache,
-        ollama_dir,
-        dirs_exist_ok=True
-    )
-    
-    print("✅ 模型已恢复，无需重新下载！")
-else:
-    print("⚠️ 未找到缓存，需要重新下载")
-```
-
-**注意**：此方法有局限性，因为 Ollama 的模型存储结构复杂，可能不完全兼容。
-
----
-
-### 方案 3: 使用云端 LLM API（高级方案⭐⭐⭐⭐）
-
-完全避免本地模型，使用云端 API。
-
-#### 可选 API
-
-1. **OpenAI API**（需付费）
-2. **Anthropic Claude API**（需付费）
-3. **Hugging Face Inference API**（免费，有限额）
-4. **Together AI**（免费额度）
-
-#### 代码修改示例
-
-修改 `entity_extractor.py`:
-
-```python
-# 原代码
-from langchain_community.chat_models import ChatOllama
-self.llm = ChatOllama(model=LOCAL_LLM, format="json", temperature=0)
-
-# 改为使用 OpenAI API
-from langchain_openai import ChatOpenAI
-self.llm = ChatOpenAI(
-    model="gpt-3.5-turbo",  # 或 gpt-4
-    temperature=0,
-    openai_api_key=os.getenv("OPENAI_API_KEY")
-)
-
-# 或使用 Hugging Face
-from langchain_community.llms import HuggingFaceHub
-self.llm = HuggingFaceHub(
-    repo_id="mistralai/Mistral-7B-Instruct-v0.1",
-    huggingfacehub_api_token=os.getenv("HUGGINGFACE_API_TOKEN")
-)
-```
-
-**优点**：
-- ✅ 无需下载模型
-- ✅ 速度快（云端 GPU）
-- ✅ 质量好（GPT-4 等高级模型）
-
-**缺点**：
-- ❌ 需要 API Key
-- ❌ 可能产生费用
-- ❌ 依赖网络
-
----
-
-### 方案 4: 预构建 Docker 镜像（技术方案⭐⭐）
-
-创建包含预下载模型的 Docker 镜像。
-
-**步骤**：
-1. 本地构建包含 Ollama + 模型的 Docker 镜像
-2. 推送到 Docker Hub
-3. 在 Kaggle 中拉取该镜像
-
-**局限**：Kaggle 对 Docker 支持有限。
-
----
-
-## 🎯 最佳实践推荐
-
-### 推荐组合策略
-
-**快速开发/测试**：
-```python
-# 使用 phi 模型（平衡速度和质量）
-LOCAL_LLM = "phi"
-```
-
-**生产环境**：
-```python
-# 使用云端 API（速度快、质量高）
-# 在 Kaggle Secrets 中设置 OPENAI_API_KEY
-from langchain_openai import ChatOpenAI
-llm = ChatOpenAI(model="gpt-3.5-turbo")
-```
-
-**完全离线**：
-```python
-# 使用 tinyllama（最快下载）
-LOCAL_LLM = "tinyllama"
-```
-
----
-
-## 📋 Kaggle 完整工作流程（优化版）
-
-### 单元格 1: 初始化
-```python
-import os, subprocess, sys
-
-os.chdir('/kaggle/working')
-if not os.path.exists('adaptive_RAG'):
-    subprocess.run(['git', 'clone', 'https://github.com/LannyCodes/adaptive_RAG.git'])
-
-os.chdir('adaptive_RAG')
-
-# 修改配置使用更小的模型
-with open('config.py', 'r') as f:
-    content = f.read()
-
-content = content.replace('LOCAL_LLM = "mistral"', 'LOCAL_LLM = "phi"')
-
-with open('config.py', 'w') as f:
-    f.write(content)
-
-print("✅ 已切换到 phi 模型")
-
-sys.path.insert(0, '/kaggle/working/adaptive_RAG')
-```
-
-### 单元格 2: 安装 Ollama
-```python
-# 安装 Ollama
-subprocess.run('curl -fsSL https://ollama.com/install.sh | sh', shell=True)
-
-# 启动服务
-subprocess.Popen(['ollama', 'serve'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-time.sleep(15)
-```
-
-### 单元格 3: 下载优化的模型
-```python
-import time
-
-# 使用更小的模型
-print("📥 下载 phi 模型（约1.6GB，2-3分钟）...")
-subprocess.run(['ollama', 'pull', 'phi'])
-
-print("✅ 模型下载完成")
-```
-
-### 单元格 4: 安装依赖并运行
-```python
-!pip install -r requirements_graphrag.txt -q
-
-# 继续您的处理...
-```
-
----
-
-## 🔢 时间对比
-
-| 场景 | Mistral | Phi | TinyLlama | 云端API |
-|-----|---------|-----|-----------|---------|
-| **首次下载** | 5-10分钟 | 2-3分钟 | 1分钟 | 0分钟 |
-| **后续会话** | 5-10分钟 | 2-3分钟 | 1分钟 | 0分钟 |
-| **每周总耗时**<br>（5次会话） | 25-50分钟 | 10-15分钟 | 5分钟 | 0分钟 |
-
----
-
-## 💰 成本对比
-
-| 方案 | 时间成本 | 金钱成本 | 质量 |
-|-----|---------|---------|------|
-| Mistral | 高 ❌ | 免费 ✅ | 高 ✅ |
-| Phi | 中 ✅ | 免费 ✅ | 中高 ✅ |
-| TinyLlama | 低 ✅ | 免费 ✅ | 中 ⚠️ |
-| GPT-3.5 API | 极低 ✅ | 约$0.5-2/天 ⚠️ | 极高 ✅ |
-
----
-
-## 🎁 快速配置脚本
-
-将以下代码保存为 `KAGGLE_QUICK_START.py`：
-
-```python
-"""
-Kaggle 快速启动脚本 - 自动使用优化配置
-"""
-
-import os
-import subprocess
-import sys
-import time
-
-print("🚀 Kaggle 快速启动（优化版）")
-print("="*60)
-
-# 1. 克隆项目
-os.chdir('/kaggle/working')
-if not os.path.exists('adaptive_RAG'):
-    subprocess.run(['git', 'clone', 'https://github.com/LannyCodes/adaptive_RAG.git'])
-
-os.chdir('adaptive_RAG')
-
-# 2. 自动选择模型（根据配置）
-USE_SMALL_MODEL = True  # 👈 改为 False 使用 Mistral
-
-if USE_SMALL_MODEL:
-    MODEL_NAME = "phi"
-    print("✅ 使用优化模型: phi (1.6GB)")
-else:
-    MODEL_NAME = "mistral"
-    print("✅ 使用标准模型: mistral (4GB)")
-
-# 修改配置
-with open('config.py', 'r') as f:
-    content = f.read()
-
-content = content.replace(
-    'LOCAL_LLM = "mistral"',
-    f'LOCAL_LLM = "{MODEL_NAME}"'
-)
-
-with open('config.py', 'w') as f:
-    f.write(content)
-
-# 3. 安装 Ollama
-check = subprocess.run(['which', 'ollama'], capture_output=True)
-if check.returncode != 0:
-    print("📥 安装 Ollama...")
-    subprocess.run('curl -fsSL https://ollama.com/install.sh | sh', shell=True)
-
-# 4. 启动服务
-subprocess.Popen(['ollama', 'serve'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-time.sleep(15)
-
-# 5. 下载模型
-print(f"📦 下载 {MODEL_NAME} 模型...")
-subprocess.run(['ollama', 'pull', MODEL_NAME])
-
-# 6. 安装依赖
-print("📦 安装依赖...")
-subprocess.run([sys.executable, '-m', 'pip', 'install', '-r', 'requirements_graphrag.txt', '-q'])
-
-sys.path.insert(0, '/kaggle/working/adaptive_RAG')
-
-print("\n" + "="*60)
-print("✅ 环境准备完成！")
-print("="*60)
-print(f"\n📌 使用模型: {MODEL_NAME}")
-print("📌 现在可以运行 GraphRAG 索引了")
-```
-
----
-
-## 总结
-
-**最推荐的解决方案**：
-
-1. ⭐⭐⭐⭐⭐ **使用 Phi 模型** - 平衡了速度和质量
-2. ⭐⭐⭐⭐ **使用云端 API** - 适合生产环境
-3. ⭐⭐⭐ **使用 TinyLlama** - 快速测试
-
-**实际操作**：
-- 只需将 `config.py` 中的 `LOCAL_LLM = "mistral"` 改为 `LOCAL_LLM = "phi"`
-- 或在 Kaggle 中运行时自动替换（见快速启动脚本）
-
-这样每次会话只需 2-3 分钟下载模型，而不是 5-10 分钟！

TIMEOUT_QUICK_FIX_CN.md

@@ -1,324 +0,0 @@
-# 超时问题快速修复指南
-
-## 🚨 当前问题
-
-您遇到了这个错误：
-```
-🔄 提取实体 (尝试 1/3)... ❌ 错误: HTTPConnectionPool(host='localhost', port=11434): Read timed out. (read timeout=60)
-```
-
-**原因**: 文档 #56 处理时间超过60秒，Ollama 没有在规定时间内返回结果。
-
-## ⚡ 立即修复（3步搞定）
-
-### 步骤 1: 重启 Ollama 服务
-
-在 Colab 中运行：
-```bash
-!pkill -9 ollama
-!sleep 2
-!nohup ollama serve > /tmp/ollama.log 2>&1 &
-!sleep 5
-!curl http://localhost:11434/api/tags
-```
-
-### 步骤 2: 增加超时时间
-
-在您的 Colab 笔记本中，修改初始化代码：
-
-```python
-# 找到 entity_extractor.py 的导入位置，修改为：
-from entity_extractor import EntityExtractor
-
-# 创建带更长超时的提取器
-# 直接在 Python 中猴子补丁修复
-import entity_extractor
-
-# 保存原始初始化方法
-_original_init = entity_extractor.EntityExtractor.__init__
-
-# 创建新的初始化方法，默认使用更长的超时
-def _new_init(self, timeout=180, max_retries=5):
-    _original_init(self, timeout=timeout, max_retries=max_retries)
-
-# 替换初始化方法
-entity_extractor.EntityExtractor.__init__ = _new_init
-
-print("✅ 已将超时时间增加到 180 秒（3分钟）")
-```
-
-### 步骤 3: 继续处理（跳过已完成的）
-
-```python
-# 从文档 #56 继续（索引 55）
-processed_count = 55
-
-remaining_docs = doc_splits[processed_count:]
-
-graph = indexer.index_documents(
-    documents=remaining_docs,
-    batch_size=3,  # 减小批次大小
-    save_path="/content/drive/MyDrive/knowledge_graph.pkl"
-)
-```
-
-## 🎯 完整的 Colab 代码块
-
-直接复制粘贴到 Colab 新的代码单元格：
-
-```python
-print("🔧 开始修复超时问题...")
-print("="*60)
-
-# ========== 第1步: 重启 Ollama ==========
-print("\n1️⃣ 重启 Ollama 服务...")
-!pkill -9 ollama
-!sleep 2
-!nohup ollama serve > /tmp/ollama.log 2>&1 &
-!sleep 5
-
-# 验证 Ollama 已启动
-import requests
-try:
-    response = requests.get('http://localhost:11434/api/tags', timeout=5)
-    if response.status_code == 200:
-        print("✅ Ollama 服务运行正常")
-    else:
-        print("⚠️ Ollama 可能未正常启动")
-except:
-    print("❌ Ollama 服务未响应，请检查日志")
-
-# ========== 第2步: 增加超时时间 ==========
-print("\n2️⃣ 修改超时配置...")
-
-import sys
-sys.path.insert(0, '/content/drive/MyDrive/adaptive_RAG')
-
-import entity_extractor
-
-# 保存原始初始化
-_original_init = entity_extractor.EntityExtractor.__init__
-
-# 新的初始化方法：默认3分钟超时，5次重试
-def _new_init(self, timeout=180, max_retries=5):
-    from langchain_community.chat_models import ChatOllama
-    from langchain_core.output_parsers import JsonOutputParser
-    from config import LOCAL_LLM
-    try:
-        from langchain_core.prompts import PromptTemplate
-    except ImportError:
-        from langchain.prompts import PromptTemplate
-    import time
-    
-    self.llm = ChatOllama(
-        model=LOCAL_LLM, 
-        format="json", 
-        temperature=0,
-        timeout=timeout
-    )
-    self.max_retries = max_retries
-    
-    # 实体提取提示模板
-    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()
-
-# 应用补丁
-entity_extractor.EntityExtractor.__init__ = _new_init
-
-print("✅ 超时时间已增加到 180 秒（3分钟）")
-print("✅ 重��次数已增加到 5 次")
-
-# ========== 第3步: 继续处理 ==========
-print("\n3️⃣ 准备继续处理...")
-
-# 重新导入模块以应用更改
-import importlib
-if 'graph_indexer' in sys.modules:
-    importlib.reload(sys.modules['graph_indexer'])
-
-from graph_indexer import GraphRAGIndexer
-
-# 创建新的索引器
-indexer = GraphRAGIndexer()
-
-print("\n📋 当前状态:")
-print(f"  • 总文档数: {len(doc_splits)}")
-print(f"  • 已处理: 55 个文档（0-55）")
-print(f"  • 待处理: {len(doc_splits) - 55} 个文档（56-{len(doc_splits)-1}）")
-
-# 从文档 #56 继续
-processed_count = 55
-remaining_docs = doc_splits[processed_count:]
-
-print("\n🚀 开始处理剩余文档...")
-print("="*60)
-
-graph = indexer.index_documents(
-    documents=remaining_docs,
-    batch_size=3,  # 减小批次大小以降低负载
-    save_path="/content/drive/MyDrive/knowledge_graph_partial.pkl"
-)
-
-print("\n✅ 处理完成！")
-```
-
-## 📊 如果文档 #56 仍然超时
-
-如果增加超时后，文档 #56 仍然失败，可能是该文档内容特别复杂。可以选择跳过它：
-
-```python
-# 方案A: 跳过文档 #56
-print("跳过文档 #56，从 #57 继续...")
-processed_count = 56  # 跳过 #56
-remaining_docs = doc_splits[processed_count:]
-
-graph = indexer.index_documents(
-    documents=remaining_docs,
-    batch_size=3,
-    save_path="/content/drive/MyDrive/knowledge_graph_partial.pkl"
-)
-```
-
-或者单独检查该文档：
-
-```python
-# 方案B: 检查文档 #56 的内容
-problem_doc = doc_splits[55]  # 文档 #56（索引55）
-
-print(f"文档 #56 信息:")
-print(f"  长度: {len(problem_doc.page_content)} 字符")
-print(f"  前500字符:")
-print(f"  {problem_doc.page_content[:500]}")
-print(f"\n  后500字符:")
-print(f"  {problem_doc.page_content[-500:]}")
-
-# 如果文档太长，可以考虑分割它
-if len(problem_doc.page_content) > 3000:
-    print("\n⚠️ 文档较长，可能需要更多处理时间或分割处理")
-```
-
-## 🔍 监控进度
-
-修复后，您将看到更详细的输出：
-
-```
-⚙️  === 批次 19/20 (文档 56-58) ===
-
-🔍 文档 #56: 开始提取...
-   🔄 提取实体 (尝试 1/5)... ✅ 提取到 8 个实体
-   🔄 提取关系 (尝试 1/5)... ✅ 提取到 5 个关系
-📊 文档 #56 完成: 8 实体, 5 关系
-```
-
-## 📌 参数说明
-
-| 参数 | 原值 | 新值 | 说明 |
-|-----|------|------|------|
-| `timeout` | 60秒 | 180秒 | 单次请求最大等待时间 |
-| `max_retries` | 3次 | 5次 | 失败后重试次数 |
-| `batch_size` | 10 | 3 | 每批次处理的文档数 |
-
-## ⏱️ 预计时间
-
-- **每个文档**: 10-180秒（取决于复杂度）
-- **批次间隔**: 重试时有2-10秒等待
-- **总时间**: 对于100个文档，预计20-60分钟
-
-## 🆘 如果问题持续
-
-### 检查 Ollama 日志
-```bash
-!tail -n 50 /tmp/ollama.log
-```
-
-### 检查系统资源
-```python
-# 检查 GPU 内存
-!nvidia-smi
-
-# 检查 RAM
-import psutil
-print(f"内存使用: {psutil.virtual_memory().percent}%")
-```
-
-### 使用更小的模型
-如果 Mistral 太慢，可以在 `config.py` 中切换到更快的模型：
-```python
-LOCAL_LLM = "phi:latest"  # 更快但质量稍低
-# 或
-LOCAL_LLM = "llama2:7b"   # 平衡选择
-```
-
-## 📝 总结
-
-**最可能的解决方案**:
-1. ✅ 重启 Ollama（清理内存）
-2. ✅ 增加超时到 180 秒
-3. ✅ 减小批次大小到 3
-4. ✅ 从断点继续处理
-
-**紧急情况**:
-- 如果某个文档持续失败 → 跳过它
-- 如果 Ollama 崩溃 → 重启服务
-- 如果内存不足 → 使用更小的模型
-
-现在请运行上面的"完整 Colab 代码块"，应该就能解决问题了！ 🚀