feat: 完成 LLM Wiki v2 升级

- 新增知识管理系统核心文档
  - automation-hooks.md: 自动化钩子和事件驱动架构
  - knowledge-lifecycle.md: 知识生命周期和遗忘曲线
  - quality-control.md: 质量控制和自我纠正机制
  - llm-wiki-v2-reference.md: v2 参考文档

- 更新索引和架构
  - index.md: 重构为目录导航，移除详细列表
  - SCHEMA.md: 更新知识管理领域定义

- 新增辅助文档
  - hybrid-search.md: 混合搜索系统
  - systems-design/aodb-system-architecture.md: AODB系统架构

版本: LLM Wiki v2.1.0
特性: 置信度衰减、智能整合、质量验证、事件驱动自动化

airport-wiki/concepts/knowledge-management/automation-hooks.md

@@ -0,0 +1,569 @@
+---
+title: 自动化钩子与事件驱动架构
+created: 2026-04-13
+updated: 2026-04-13
+type: concept
+tags: [knowledge-management, automation, event-hooks, operations]
+confidence: 0.9
+sources_count: 5
+last_confirmed: 2026-04-13
+status: active
+relationships:
+  - target: SCHEMA.md
+    type: implements
+    detail: "v2 自动化机制"
+    confidence: 0.95
+  - target: knowledge-management/memory-lifecycle.md
+    type: triggers
+    detail: "置信度衰减和整合"
+    confidence: 0.85
+  - target: knowledge-management/knowledge-graph.md
+    type: updates
+    detail: "自动更新实体关系"
+    confidence: 0.9
+  - target: hybrid-search.md
+    type: maintains
+    detail: "嵌入和索引更新"
+    confidence: 0.9
+---
+
+# ⚡ 自动化钩子与事件驱动架构
+
+基于 **LLM Wiki v2** 的事件驱动维护系统，为机场智能化工程 wiki 提供自动化知识管理。通过事件钩子响应 wiki 操作，减少手动维护负担。
+
+> **核心目标**：将手动知识维护转变为事件驱动的自动化流程，确保 wiki 内容的新鲜度、一致性和质量。
+
+---
+
+## 🏗️ 事件架构总览
+
+### 事件类型与触发器
+| 事件类型 | 触发器 | 触发条件 | 响应延迟 |
+|----------|--------|----------|----------|
+| **来源新增** | 文件系统监视 | `raw/` 中新增 `.md` 文件 | 即时 (15s) |
+| **页面创建** | `write_file()` 调用 | `concepts/`, `entities/` 等目录 | 即时 (5s) |
+| **页面更新** | `patch()` 调用 | 现有页面内容修改 | 即时 (5s) |
+| **页面归档** | 文件移动至 `_archive/` | 手动操作或自动 supersede | 即时 (5s) |
+| **用户查询** | `web_search()` 或 `search_files()` | 搜索操作 | 异步 (<60s) |
+| **定时任务** | cron 调度器 | 每日/每周/每月 | 指定时间 |
+
+### 自动化钩子执行顺序
+```
+新来源 → on_new_source() → 来源解析 → 实体提取 → 页面创建/更新
+                                                      ↓
+页面创建/更新 → on_page_change() → 关系更新 → 嵌入更新 → 索引更新
+                                                      ↓
+定时任务 → cron_daily/weekly/monthly() → 质量检查 → 置信度衰减
+                                                      ↓
+用户查询 → on_user_query() → 结果记录 → 潜在答案生成 → 反馈学习
+```
+
+---
+
+## 🔧 主要钩子实现
+
+### 1️⃣ `on_new_source()` - 新来源自动摄入
+```python
+def on_new_source(source_path: str):
+    """
+    处理 raw/ 目录中的新来源文件
+    1. 解析来源内容
+    2. 提取实体和事实
+    3. 创建/更新 wiki 页面
+    4. 更新相关索引
+    """
+    
+    # 1. 读取并解析来源
+    content = read_file(source_path)
+    metadata = extract_metadata(content)  # 作者、日期、类型等
+    
+    # 2. 提取实体和事实
+    entities = extract_entities(content)
+    facts = extract_facts(content, entities)
+    
+    # 3. 更新现有页面或创建新页面
+    for fact in facts:
+        target_page = find_or_create_page(fact.topic)
+        
+        # 检查是否有冲突
+        conflict = check_conflict(target_page.content, fact.content)
+        
+        if conflict:
+            # 触发 supersession 流程
+            supersede_page(target_page, fact.content, source_path)
+        else:
+            # 追加新事实
+            update_page(target_page, fact.content, source_path)
+    
+    # 4. 更新嵌入和图谱
+    trigger_embedding_update()
+    trigger_graph_reconciliation()
+    
+    # 记录日志
+    log_event("source_ingested", {
+        "source": source_path,
+        "entities_extracted": len(entities),
+        "facts_added": len(facts),
+        "timestamp": now()
+    })
+```
+
+**机场场景示例**：
+```
+事件: 新增 raw/articles/shenzhen-airport-smart-gating-2026.md
+响应:
+  1. 解析文章：深圳机场2026年智能登机口升级
+  2. 提取实体：深圳机场、SITA、生物识别走廊
+  3. 更新页面：
+     - concepts/smart-gating.md → 添加深圳案例
+     - entities/shenzhen-airport.md → 更新智能登机口信息
+  4. 更新关系：深圳机场 → uses → 生物识别走廊
+```
+
+### 2️⃣ `on_page_change()` - 页面变更处理
+```python
+def on_page_change(page_path: str, change_type: str, old_content: Optional[str] = None):
+    """
+    处理页面创建、更新、删除
+    参数:
+    - change_type: "create" | "update" | "delete" | "archive"
+    - old_content: 仅 update 时提供
+    """
+    
+    if change_type == "create":
+        # 新页面：初始化嵌入和关系
+        embedding = generate_embedding(page_path)
+        save_embedding(page_path, embedding)
+        
+        # 提取关系并更新图谱
+        relationships = extract_relationships(page_path)
+        update_knowledge_graph(page_path, relationships)
+        
+    elif change_type == "update":
+        # 页面更新：检查语义变化
+        old_embedding = load_embedding(page_path)
+        new_embedding = generate_embedding(page_path)
+        
+        similarity = cosine_similarity(old_embedding, new_embedding)
+        
+        if similarity < 0.7:  # 语义显著变化
+            # 重新计算相关页面的嵌入
+            trigger_related_embeddings_update(page_path)
+            
+            # 更新所有引用该页面的关系
+            update_incoming_relationships(page_path)
+    
+    elif change_type in ["delete", "archive"]:
+        # 页面删除/归档：清理相关数据
+        remove_embedding(page_path)
+        remove_from_knowledge_graph(page_path)
+        
+        # 更新引用（设置 superseded_by 或删除链接）
+        update_references_to_page(page_path, change_type)
+    
+    # 更新搜索索引
+    update_search_index(page_path, change_type)
+    
+    log_event("page_changed", {
+        "page": page_path,
+        "type": change_type,
+        "semantic_change": similarity if change_type == "update" else None,
+        "timestamp": now()
+    })
+```
+
+### 3️⃣ `cron_weekly()` - 每周维护任务
+```python
+def cron_weekly():
+    """
+    每周日自动执行的维护任务
+    1. 完整性检查 (lint)
+    2. 置信度衰减和更新
+    3. 嵌入重新生成
+    4. 性能分析
+    """
+    
+    print("=== 每周维护任务开始 ===")
+    start_time = now()
+    
+    # 1. 运行完整性检查
+    lint_report = run_lint_check()
+    
+    # 自动修复可修复的问题
+    auto_fixed = lint_report.auto_fix()
+    
+    # 记录需要手动干预的问题
+    manual_tasks = lint_report.get_manual_tasks()
+    
+    # 2. 置信度衰减
+    decayed_pages = decay_confidence_scores()
+    
+    # 3. 嵌入重新生成（全量）
+    pages_updated = regenerate_all_embeddings()
+    
+    # 4. 搜索索引重建
+    rebuild_search_index()
+    
+    # 5. 性能分析
+    performance_report = analyze_search_performance()
+    
+    # 6. 生成维护报告
+    report = generate_maintenance_report({
+        "duration_seconds": (now() - start_time).total_seconds(),
+        "lint_fixed": auto_fixed,
+        "lint_manual": len(manual_tasks),
+        "pages_decayed": len(decayed_pages),
+        "embeddings_regenerated": pages_updated,
+        "search_metrics": performance_report.metrics,
+        "timestamp": now()
+    })
+    
+    # 保存报告
+    save_report(report, "weekly-maintenance")
+    
+    # 如有需要手动干预的问题，发送通知
+    if manual_tasks:
+        notify_maintainer("手动维护任务待处理", manual_tasks)
+    
+    print(f"=== 每周维护任务完成，耗时 {report.duration_seconds}s ===")
+    
+    return report
+```
+
+### 4️⃣ `on_user_query()` - 查询响应与学习
+```python
+def on_user_query(query: str, results: List[str], user_feedback: Optional[Dict] = None):
+    """
+    处理用户搜索查询
+    1. 记录查询模式
+    2. 潜在答案生成
+    3. 质量评估和反馈学习
+    """
+    
+    # 1. 查询分类和记录
+    query_type = classify_query(query)
+    
+    log_search_event({
+        "query": query,
+        "type": query_type,
+        "results_count": len(results),
+        "user_id": get_user_id(),  # 匿名或会话ID
+        "timestamp": now()
+    })
+    
+    # 2. 检查是否需要生成新答案
+    if should_generate_answer(query, results):
+        answer = generate_potential_answer(query, results)
+        
+        # 评估答案质量
+        quality_score = evaluate_answer_quality(answer, query, results)
+        
+        if quality_score > 0.8:  # 高质量答案
+            # 自动创建/更新查询页面
+            create_query_page(query, answer, quality_score)
+            
+            log_event("answer_generated", {
+                "query": query,
+                "answer_page": f"queries/{slugify(query)}.md",
+                "quality_score": quality_score,
+                "timestamp": now()
+            })
+    
+    # 3. 处理用户反馈（如有）
+    if user_feedback:
+        process_user_feedback(query, results, user_feedback)
+        
+        # 更新搜索排名权重
+        update_search_weights(query_type, user_feedback)
+    
+    # 4. 查询模式分析
+    analyze_query_patterns(query, results)
+    
+    return {
+        "logged": True,
+        "query_type": query_type,
+        "potential_answer_generated": should_generate_answer(query, results),
+        "feedback_processed": bool(user_feedback)
+    }
+```
+
+---
+
+## ⏰ 定时任务调度
+
+### 每日任务 (`cron_daily`)
+```python
+SCHEDULE = {
+    "daily": {
+        "time": "02:30",  # 凌晨执行，避免影响使用
+        "tasks": [
+            "verify_recent_changes",  # 检查24小时内变更
+            "update_recommendations",  # 更新推荐系统
+            "clean_temp_files",       # 清理临时文件
+            "backup_incremental"     # 增量备份
+        ]
+    }
+}
+
+def cron_daily():
+    """每日凌晨执行的任务"""
+    tasks = [
+        # 1. 验证最近变更
+        verify_recent_changes(since=datetime.now() - timedelta(days=1)),
+        
+        # 2. 更新个性化推荐
+        update_recommendations(),
+        
+        # 3. 清理临时文件
+        clean_temp_files(max_age=timedelta(days=7)),
+        
+        # 4. 增量备份
+        backup_incremental(target="s3://wiki-backups/daily/")
+    ]
+    
+    return execute_tasks(tasks, name="daily_maintenance")
+```
+
+### 每周任务 (`cron_weekly`)
+```python
+def cron_weekly():
+    """每周日执行的全量维护"""
+    return {
+        "lint": run_lint_check(),
+        "embeddings": regenerate_all_embeddings(),
+        "confidence": decay_confidence_scores(),
+        "index": rebuild_search_index(),
+        "report": generate_weekly_report()
+    }
+```
+
+### 每月任务 (`cron_monthly`)
+```python
+def cron_monthly():
+    """每月1日执行的深度维护"""
+    return {
+        "archival": archive_stale_content(older_than=timedelta(days=180)),
+        "model_evaluation": evaluate_embedding_models(),
+        "capacity_planning": analyze_growth_trends(),
+        "security_audit": run_security_checks(),
+        "comprehensive_report": generate_monthly_report()
+    }
+```
+
+---
+
+## 🚀 实施部署
+
+### 阶段 1：基础钩子（当前）
+- ✅ `on_page_change()` 记录至日志
+- ✅ 新增来源手动触发处理
+- 🔄 定期 lint 检查（手动）
+
+### 阶段 2：自动化管道（1-2周）
+- 🔄 文件系统监视：`raw/` 新增自动触发
+- 🔄 页面变更自动更新嵌入和关系
+- 🔄 每周自动维护脚本
+- 🔄 搜索结果记录与分析
+
+### 阶段 3：高级自动化（1个月）
+- 🔄 智能答案生成（质量阈值 >0.8）
+- 🔄 自适应权重调整（基于用户反馈）
+- 🔄 异常检测和自动修复
+- 🔄 多环境部署（开发/测试/生产）
+
+### 阶段 4：智能运维（未来）
+- 🔄 预测性维护（基于历史模式）
+- 🔄 A/B 测试搜索算法
+- 🔄 跨wiki知识同步
+- 🔄 故障自愈能力
+
+---
+
+## 🔧 技术实现细节
+
+### 钩子注册机制
+```python
+class HookRegistry:
+    """事件钩子注册中心"""
+    
+    def __init__(self):
+        self.hooks = defaultdict(list)
+    
+    def register(self, event_type: str, callback: Callable, priority: int = 0):
+        """注册钩子"""
+        self.hooks[event_type].append({
+            "callback": callback,
+            "priority": priority
+        })
+        self.hooks[event_type].sort(key=lambda x: x["priority"])
+    
+    def trigger(self, event_type: str, **kwargs):
+        """触发事件"""
+        for hook in self.hooks.get(event_type, []):
+            try:
+                hook["callback"](**kwargs)
+            except Exception as e:
+                log_error(f"钩子执行失败: {event_type}", e)
+
+# 全局钩子注册器
+hooks = HookRegistry()
+
+# 注册示例
+hooks.register("page_created", on_page_change, priority=10)
+hooks.register("source_added", on_new_source, priority=5)
+```
+
+### 文件系统监视
+```python
+import watchdog
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler
+
+class WikiFileHandler(FileSystemEventHandler):
+    """监视 raw/ 目录的变更"""
+    
+    def on_created(self, event):
+        if event.is_directory:
+            return
+        
+        path = event.src_path
+        if path.startswith("/raw/") and path.endswith(".md"):
+            # 触发来源处理钩子
+            hooks.trigger("source_added", source_path=path)
+    
+    def on_modified(self, event):
+        if event.is_directory:
+            return
+        
+        path = event.src_path
+        if not path.startswith("/raw/"):
+            # 触发页面变更钩子
+            hooks.trigger("page_changed", page_path=path, change_type="update")
+
+# 启动监视器
+observer = Observer()
+observer.schedule(WikiFileHandler(), "/path/to/wiki", recursive=True)
+observer.start()
+```
+
+### 定时任务调度器
+```python
+import schedule
+import time
+
+def setup_scheduler():
+    """配置定时任务"""
+    
+    # 每日凌晨任务
+    schedule.every().day.at("02:30").do(cron_daily)
+    
+    # 每周日任务  
+    schedule.every().sunday.at("03:00").do(cron_weekly)
+    
+    # 每月1日任务
+    schedule.every().month.at("04:00").do(cron_monthly)
+    
+    print("定时任务已配置")
+    
+    # 运行调度器（后台线程）
+    import threading
+    
+    def run_scheduler():
+        while True:
+            schedule.run_pending()
+            time.sleep(60)  # 每分钟检查一次
+    
+    thread = threading.Thread(target=run_scheduler, daemon=True)
+    thread.start()
+
+# 应用启动时调用
+setup_scheduler()
+```
+
+---
+
+## 📊 监控与告警
+
+### 关键指标监控
+| 指标 | 阈值 | 告警级别 | 响应动作 |
+|------|------|----------|----------|
+| **处理失败率** | >5% | 警告 | 检查日志，重启服务 |
+| **嵌入更新延迟** | >24h | 警告 | 手动触发嵌入生成 |
+| **页面冲突数量** | >10 | 警告 | 审核冲突内容 |
+| **搜索查询失败** | >20% | 严重 | 检查搜索索引 |
+| **磁盘使用率** | >80% | 警告 | 清理或扩容 |
+
+### 告警规则示例
+```yaml
+alerts:
+  - name: "high_failure_rate"
+    condition: "rate(failed_hooks_total[5m]) / rate(hooks_total[5m]) > 0.05"
+    severity: "warning"
+    description: "钩子执行失败率超过5%"
+    actions: ["send_slack", "create_jira"]
+  
+  - name: "search_degradation"  
+    condition: "search_response_time_p95 > 3000"
+    severity: "critical"
+    description: "搜索P95响应时间超过3秒"
+    actions: ["page_oncall", "rollback_search"]
+```
+
+---
+
+## 🔄 故障恢复流程
+
+### 常见故障场景
+1. **钩子执行失败**
+   ```bash
+   # 1. 查看错误日志
+   tail -f /var/log/wiki/hooks.log
+   
+   # 2. 暂时禁用问题钩子
+   disable_hook("on_page_change", "problematic_callback")
+   
+   # 3. 手动执行受影响操作
+   run_manual_cleanup()
+   ```
+
+2. **嵌入生成中断**
+   ```bash
+   # 1. 检查嵌入存储完整性
+   verify_embeddings_integrity()
+   
+   # 2. 重新生成受影响页面
+   regenerate_embeddings_for_pages(since="2026-04-10")
+   
+   # 3. 重建搜索索引
+   rebuild_search_index()
+   ```
+
+3. **关系图谱不一致**
+   ```python
+   # 自动一致性检查
+   def reconcile_knowledge_graph():
+       # 1. 检测孤立实体
+       orphans = find_orphaned_entities()
+       
+       # 2. 检查关系对称性
+       mismatches = validate_relationship_symmetry()
+       
+       # 3. 修复不一致
+       fix_inconsistencies(orphans + mismatches)
+       
+       return {"fixed": len(orphans + mismatches)}
+   ```
+
+---
+
+## 📚 相关文档
+
+- [[knowledge-management/memory-lifecycle.md]] - 置信度衰减和整合机制
+- [[knowledge-management/knowledge-graph.md]] - 实体关系自动提取
+- [[hybrid-search.md]] - 搜索结果记录和权重调整
+- [[wiki-backup-recovery.md]] - 备份和恢复流程
+- [[performance-monitoring.md]] - 系统性能监控
+
+---
+
+> **状态**: 当前实现基础钩子记录。下一步：部署文件系统监视和定时任务。最后更新：2026-04-13。

airport-wiki/concepts/knowledge-management/knowledge-lifecycle.md

@@ -0,0 +1,474 @@
+---
+title: 知识生命周期与遗忘曲线
+created: 2026-04-13
+updated: 2026-04-13
+type: concept
+tags: [knowledge-management, knowledge-lifecycle, confidence-decay, supersession]
+confidence: 0.9
+sources_count: 3
+last_confirmed: 2026-04-13
+status: active
+relationships:
+  - target: automation-hooks.md
+    type: governed-by
+    detail: "置信度衰减触发事件"
+    confidence: 0.95
+  - target: knowledge-management/knowledge-graph.md
+    type: updates
+    detail: "实体关系老化机制"
+    confidence: 0.85
+  - target: hybrid-search.md
+    type: influences
+    detail: "搜索排名权重衰减"
+    confidence: 0.8
+  - target: quality-control.md
+    type: informs
+    detail: "质量评估和归档决策"
+    confidence: 0.9
+---
+
+# 🔄 知识生命周期与遗忘曲线
+
+模拟人类记忆的**置信度衰减**和**层次化整合**机制，为机场智能化 wiki 建立动态的知识管理系统。通过时间衰减、源验证和层次整合，确保 wiki 内容的时效性和准确性。
+
+> **核心理念**：知识不是静态的，而是随时间演化的有机体。新知识活跃，旧知识衰减，冲突知识整合。
+
+---
+
+## 🧠 记忆分层模型
+
+### 1️⃣ **工作记忆层** (Working Memory)
+| 特征 | 处理机制 | 时间窗口 |
+|------|----------|----------|
+| **新加入的知识** | 高置信度 (0.8-1.0) | 1-30 天 |
+| **主动使用频率高** | 强化学习 | 短期活跃 |
+| **来源新鲜** | 来源评分高 | 即时可用 |
+| **易于修改** | 标记为待验证 | 高度可变 |
+
+**适用场景**：刚发布的政策、新机场案例、技术规格更新
+
+### 2️⃣ **长期记忆层** (Long-term Memory)
+| 特征 | 处理机制 | 时间窗口 |
+|------|----------|----------|
+| **已验证的知识** | 中等置信度 (0.5-0.8) | 31-365 天 |
+| **多源验证** | 冲突解决完毕 | 稳定引用 |
+| **整合完善** | 关联其他知识 | 结构性存储 |
+| **定期回顾** | 周期性强化 | 访问频率中 |
+
+**适用场景**：成熟技术标准、核心运营流程、基础架构文档
+
+### 3️⃣ **归档记忆层** (Archived Memory)
+| 特征 | 处理机制 | 时间窗口 |
+|------|----------|----------|
+| **过时但参考性** | 低置信度 (0.1-0.5) | >1 年 |
+| **历史价值** | 标记为过时 | 只读访问 |
+| **替代关系** | superseded_by 链接 | 背景参考 |
+| **最小维护** | 不参与搜索 | 低成本存储 |
+
+**适用场景**：旧版标准、历史案例、被替换的技术方案
+
+---
+
+## 📉 置信度衰减机制
+
+### 衰减函数
+```python
+def decay_confidence(current_confidence: float, 
+                     age_days: int,
+                     usage_frequency: float,
+                     sources_count: int) -> float:
+    """
+    计算置信度衰减
+    参数:
+    - current_confidence: 当前置信度 (0-1)
+    - age_days: 知识创建天数
+    - usage_frequency: 最近30天访问频率 (0-1)
+    - sources_count: 引用来源数量
+    """
+    
+    # 基础衰减因子：时间衰减（类似艾宾浩斯遗忘曲线）
+    base_decay = 0.95 ** (age_days / 30)  # 每月衰减5%
+    
+    # 强化因子：使用频率和来源数量
+    reinforcement = (usage_frequency * 0.3) + (min(sources_count, 5) * 0.05)
+    
+    # 应用衰减
+    new_confidence = current_confidence * base_decay
+    
+    # 应用强化（减缓衰减）
+    new_confidence += (1 - base_decay) * reinforcement
+    
+    # 确保在 [0.05, 1.0] 范围内
+    return max(0.05, min(1.0, new_confidence))
+```
+
+### 衰减策略表
+| 衰减因子 | 影响权重 | 触发条件 | 调整幅度 |
+|----------|----------|----------|----------|
+| **时间衰减** | 60% | 创建时间 >30 天 | -2%/月 |
+| **使用频率** | 20% | 每月访问次数 | ±0.5%/次 |
+| **来源数量** | 15% | 引用来源增减 | ±1%/个 |
+| **冲突数量** | 5% | 发现矛盾事实 | -5%/冲突 |
+| **用户反馈** | 额外 | 明确确认/否认 | ±10%/次 |
+
+### 衰减示例计算
+```python
+# 示例：智能登机口技术页面
+page_confidence = {
+    "current": 0.85,         # 当前置信度
+    "age_days": 90,          # 创建90天
+    "usage_frequency": 0.6,  # 中等使用频率
+    "sources_count": 3,      # 3个来源
+    "conflicts": 1           # 1个冲突
+}
+
+# 计算衰减
+new_confidence = decay_confidence(
+    current_confidence=0.85,
+    age_days=90,
+    usage_frequency=0.6,
+    sources_count=3
+)
+
+# 应用冲突惩罚
+if page_confidence["conflicts"] > 0:
+    new_confidence -= 0.05 * page_confidence["conflicts"]
+
+print(f"原始置信度: 0.85 → 衰减后: {new_confidence:.2f}")
+# 输出: 原始置信度: 0.85 → 衰减后: 0.76
+```
+
+---
+
+## 🔄 知识整合层次
+
+### 层次 1: **事实级整合**
+```python
+def integrate_facts(existing_fact: Fact, new_fact: Fact) -> IntegrationResult:
+    """
+    整合新事实到现有知识
+    返回: 保持原样 | 更新 | 并列 | 弃用
+    """
+    
+    # 1. 检查直接冲突
+    if is_direct_conflict(existing_fact, new_fact):
+        return resolve_conflict(existing_fact, new_fact)
+    
+    # 2. 检查互补性
+    if is_complementary(existing_fact, new_fact):
+        return merge_facts(existing_fact, new_fact)
+    
+    # 3. 检查相关性
+    if is_related(existing_fact, new_fact):
+        return link_facts(existing_fact, new_fact)
+    
+    # 4. 无关联则独立存储
+    return IntegrationResult.KEEP_BOTH
+```
+
+### 层次 2: **页面级整合**
+```python
+def integrate_pages(target_page: Page, new_content: str, source: str):
+    """
+    整合新内容到现有页面
+    """
+    
+    # 1. 提取关键事实
+    new_facts = extract_facts(new_content)
+    
+    # 2. 与页面现有事实比较
+    for fact in new_facts:
+        # 查找匹配的现有事实
+        matches = find_matching_facts(target_page, fact)
+        
+        if not matches:
+            # 新事实：添加
+            target_page.add_fact(fact, source)
+            
+        elif len(matches) == 1:
+            # 匹配事实：整合
+            result = integrate_facts(matches[0], fact)
+            
+            if result == IntegrationResult.UPDATE:
+                # 更新现有事实（提高置信度）
+                matches[0].update(fact, source)
+            elif result == IntegrationResult.DEPRECATE:
+                # 弃用旧事实
+                matches[0].mark_deprecated(fact, source)
+                
+        else:
+            # 多个匹配：需要人工审核
+            target_page.flag_for_review(fact, matches)
+    
+    # 3. 更新页面置信度
+    target_page.recalculate_confidence()
+```
+
+### 层次 3: **主题级整合**
+```python
+def integrate_topic(topic: str, new_sources: List[str]):
+    """
+    整合新来源到主题（如"智能登机口"）
+    """
+    
+    # 1. 获取主题相关页面
+    related_pages = get_pages_by_topic(topic)
+    
+    # 2. 对每个新来源
+    for source in new_sources:
+        content = read_source(source)
+        
+        # 3. 分发给相关页面
+        for page in related_pages:
+            # 检查相关性
+            relevance = calculate_relevance(content, page)
+            
+            if relevance > 0.3:
+                integrate_pages(page, content, source)
+        
+        # 4. 创建新页面（如需）
+        uncovered_aspects = find_uncovered_aspects(content, related_pages)
+        
+        for aspect in uncovered_aspects:
+            create_new_page(aspect, content, source)
+    
+    # 5. 主题级置信度更新
+    update_topic_confidence(topic)
+```
+
+### 层次 4: **领域级整合**
+```python
+def integrate_domain(domain: str, time_period: str = "monthly"):
+    """
+    跨主题的领域级整合（如"机场运营技术"）
+    """
+    
+    # 1. 获取领域内所有主题
+    topics = get_topics_in_domain(domain)
+    
+    # 2. 识别跨主题模式
+    cross_topic_patterns = analyze_cross_topic_patterns(topics)
+    
+    # 3. 整合重复信息
+    deduplicate_across_topics(topics)
+    
+    # 4. 更新主题关系图
+    update_domain_relationship_graph(domain, topics)
+    
+    # 5. 生成领域报告
+    report = generate_domain_integration_report(domain, topics)
+    
+    return report
+```
+
+---
+
+## 🗑️ 知识淘汰与归档
+
+### 淘汰决策树
+```
+开始
+  ↓
+置信度 < 0.3 ?
+  ├─ 是 → 标记为过时
+  └─ 否 → 
+        ↓
+       有更新的替代版本？
+          ├─ 是 → superseded_by 链接
+          └─ 否 →
+                ↓
+                创建时间 > 2 年？
+                  ├─ 是 → 归档建议
+                  └─ 否 → 保持活跃
+```
+
+### 归档流程
+```python
+def archive_knowledge():
+    """
+    自动知识归档流程
+    1. 识别候选
+    2. 验证替代关系
+    3. 执行归档
+    4. 更新引用
+    """
+    
+    # 1. 识别归档候选
+    candidates = find_archive_candidates()
+    
+    for candidate in candidates:
+        # 2. 检查是否有替代版本
+        replacement = find_replacement(candidate)
+        
+        if replacement:
+            # 3. 建立 superseded_by 关系
+            candidate.superseded_by = replacement
+            
+            # 4. 移动页面到归档目录
+            archive_path = move_to_archive(candidate)
+            
+            # 5. 更新所有引用
+            update_references(candidate, replacement)
+            
+            log_event("page_archived", {
+                "page": candidate.path,
+                "replacement": replacement.path,
+                "reason": "superseded_by",
+                "timestamp": now()
+            })
+        else:
+            # 无替代版本：降低搜索权重
+            candidate.search_weight *= 0.1
+            
+            log_event("page_deprecated", {
+                "page": candidate.path,
+                "reason": "no_replacement",
+                "timestamp": now()
+            })
+    
+    return {"archived": len(candidates)}
+```
+
+---
+
+## 🎯 置信度驱动的搜索排名
+
+### 搜索评分算法
+```python
+def calculate_search_score(page: Page, query: str, user_context: Dict) -> float:
+    """
+    结合置信度、相关性和时效性的搜索评分
+    """
+    
+    # 1. 基础文本相关性 (BM25)
+    text_relevance = bm25_score(page.content, query)
+    
+    # 2. 语义相关性 (嵌入相似度)
+    semantic_relevance = embedding_similarity(page.embedding, query_embedding)
+    
+    # 3. 置信度调整
+    confidence_adjustment = page.confidence ** 2  # 平方加权，高置信度优势更大
+    
+    # 4. 时效性调整（新知识优先）
+    recency_adjustment = 1.0 / (1 + page.age_days / 180)  # 半年衰减一半
+    
+    # 5. 用户个性化（如有历史数据）
+    personalization = calculate_personalization_score(page, user_context)
+    
+    # 综合评分
+    score = (
+        text_relevance * 0.4 +
+        semantic_relevance * 0.4 +
+        confidence_adjustment * 0.15 +
+        recency_adjustment * 0.05 +
+        personalization * 0.1  # 如果用户有历史数据，否则为0
+    )
+    
+    return score
+```
+
+### 置信度阈值
+| 置信度区间 | 搜索可见性 | 推荐系统 | 自动引用 |
+|------------|------------|----------|----------|
+| **0.8-1.0** | 最高优先级 | 主动推荐 | 自动引用 |
+| **0.6-0.79** | 正常显示 | 可能推荐 | 谨慎引用 |
+| **0.4-0.59** | 较低权重 | 很少推荐 | 标记警告 |
+| **0.2-0.39** | 需明确搜索 | 不推荐 | 避免引用 |
+| **<0.2** | 隐藏（归档） | 不推荐 | 不引用 |
+
+---
+
+## 📊 生命周期监控
+
+### 仪表板指标
+```python
+def get_lifecycle_metrics():
+    """
+    返回知识生命周期关键指标
+    """
+    return {
+        "total_pages": count_pages(),
+        "by_confidence": {
+            "high": count_pages(confidence_min=0.8),
+            "medium": count_pages(confidence_min=0.5, confidence_max=0.79),
+            "low": count_pages(confidence_min=0.2, confidence_max=0.49),
+            "archived": count_pages(confidence_max=0.19)
+        },
+        "decay_rate": calculate_average_decay_rate(),
+        "conflict_resolution_rate": get_conflict_resolution_rate(),
+        "archival_rate": count_archived_last_month(),
+        "average_age_days": get_average_page_age()
+    }
+```
+
+### 健康检查
+```python
+def health_check_lifecycle():
+    """
+    生命周期系统健康检查
+    """
+    issues = []
+    
+    # 检查过度衰减
+    if get_average_decay_rate() > 0.1:
+        issues.append("置信度衰减过快")
+    
+    # 检查冲突积压
+    if count_unresolved_conflicts() > 20:
+        issues.append("未解决冲突过多")
+    
+    # 检查归档堆积
+    if count_candidates_for_archive() > 50:
+        issues.append("归档候选积压")
+    
+    # 检查更新频率
+    if days_since_last_integration() > 30:
+        issues.append("整合操作长期未执行")
+    
+    return {
+        "status": "healthy" if not issues else "needs_attention",
+        "issues": issues,
+        "metrics": get_lifecycle_metrics()
+    }
+```
+
+---
+
+## 🚀 实施路线图
+
+### 阶段 1：基础衰减（当前）
+- ✅ 页面级置信度字段
+- ✅ 简单的基于时间的衰减
+- 🔄 每周自动衰减脚本
+
+### 阶段 2：智能整合（2-4周）
+- 🔄 事实级冲突检测
+- 🔄 页面级整合算法
+- 🔄 置信度驱动的搜索排名
+- 🔄 基础仪表板
+
+### 阶段 3：高级生命周期（1-2月）
+- 🔄 主题级和领域级整合
+- 🔄 自适应衰减参数
+- 🔄 用户反馈集成
+- 🔄 预测性归档建议
+
+### 阶段 4：自主管理（未来）
+- 🔄 自适应的遗忘曲线
+- 🔄 跨wiki知识同步
+- 🔄 主动知识维护
+- 🔄 预测性内容生成
+
+---
+
+## 📚 相关文档
+
+- [[automation-hooks.md]] - 触发置信度衰减的自动化事件
+- [[knowledge-management/knowledge-graph.md]] - 整合过程中的关系更新
+- [[hybrid-search.md]] - 置信度驱动的搜索排名
+- [[quality-control.md]] - 质量评估和归档决策
+- [[wiki-backup-recovery.md]] - 归档内容的备份管理
+
+---
+
+> **状态**: 基础置信度衰减已实现。下一步：集成智能冲突检测和整合算法。最后更新：2026-04-13。

airport-wiki/concepts/knowledge-management/llm-wiki-v2-reference.md

@@ -0,0 +1,584 @@
+---
+title: LLM Wiki v2 参考文档
+created: 2026-04-13
+updated: 2026-04-13
+type: meta
+tags: [llm-wiki, v2, reference, architecture]
+confidence: 0.9
+sources_count: 5
+last_confirmed: 2026-04-13
+status: active
+relationships:
+  - target: SCHEMA.md
+    type: implements
+    detail: "v2 架构实现"
+    confidence: 0.95
+  - target: concepts/knowledge-management/automation-hooks.md
+    type: core-component
+    detail: "自动化钩子系统"
+    confidence: 0.9
+  - target: concepts/knowledge-management/knowledge-lifecycle.md
+    type: core-component
+    detail: "知识生命周期"
+    confidence: 0.9
+  - target: concepts/knowledge-management/quality-control.md
+    type: core-component
+    detail: "质量控制机制"
+    confidence: 0.9
+  - target: concepts/knowledge-management/knowledge-graph.md
+    type: core-component
+    detail: "实体图管理"
+    confidence: 0.85
+  - target: concepts/knowledge-management/hybrid-search.md
+    type: core-component
+    detail: "混合搜索系统"
+    confidence: 0.85
+---
+
+# 📚 LLM Wiki v2 参考文档
+
+**机场智能化工程知识库的架构与技术实现指南**
+
+基于 Karpathy 的 LLM Wiki 理念，v2 版本引入了**动态知识管理**、**智能检索**和**自动化维护**三大核心能力。本文档详细说明架构设计、实现原理和配置方法。
+
+> **v2 核心理念**：知识是动态的有机体，需要随时间衰减、冲突整合和持续验证，而非静态的文档集合。
+
+---
+
+## 🏗️ 架构总览
+
+### 系统分层架构
+```
+应用层 (Application Layer)
+├── 搜索引擎 (Hybrid Search Engine)
+├── 关系图谱 (Knowledge Graph Browser)
+└── 质量看板 (Quality Dashboard)
+
+核心层 (Core Layer)
+├── 自动化钩子系统 (Automation Hooks)
+├── 置信度衰减引擎 (Confidence Decay Engine)
+├── 冲突检测处理器 (Conflict Detection Processor)
+└── 自我纠正机制 (Self-correction Mechanism)
+
+存储层 (Storage Layer)
+├── 向量数据库 (Vector Database)        # 嵌入存储
+├── 文档存储 (Document Store)          # Markdown/YAML
+└── 关系数据库 (Relational Database)    # 实体关系
+```
+
+### 数据流向
+```
+新来源 → 解析 → 实体提取 → 事实提取 → 冲突检测 → 置信度评估 → 存储
+                 ↓           ↓           ↓           ↓          ↓
+现有知识 ← 整合 ← 关系更新 ← 冲突解决 ← 置信度衰减 ← 质量验证 ← 定期任务
+```
+
+---
+
+## 🔧 核心组件详解
+
+### 1. **置信度系统 (Confidence System)**
+#### 置信度字段结构
+```yaml
+---
+confidence: 0.85                    # 当前置信度 (0.1-1.0)
+sources_count: 3                    # 引用来源数量
+last_confirmed: 2026-04-13         # 最后一次确认/更新
+confidence_history:                 # 置信度变化历史
+  - date: 2026-04-10
+    value: 0.80
+    reason: "new_source_added"
+  - date: 2026-04-12
+    value: 0.83
+    reason: "conflict_resolved"
+  - date: 2026-04-13
+    value: 0.85
+    reason: "weekly_decay_applied"
+decay_factors:                     # 衰减因子权重
+  time: 0.60
+  usage: 0.20
+  sources: 0.15
+  conflicts: 0.05
+---
+```
+
+#### 衰减算法
+```python
+def decay_confidence(current, age_days, usage_freq, sources_cnt, conflicts_cnt):
+    # 基础时间衰减（每月5%）
+    base_decay = 0.95 ** (age_days / 30)
+    
+    # 强化因子（使用频率和来源数量）
+    reinforcement = (usage_freq * 0.3) + (min(sources_cnt, 5) * 0.05)
+    
+    # 应用衰减
+    new_confidence = current * base_decay + (1 - base_decay) * reinforcement
+    
+    # 冲突惩罚
+    new_confidence -= 0.05 * conflicts_cnt
+    
+    # 边界处理
+    return max(0.05, min(1.0, new_confidence))
+```
+
+### 2. **实体图管理系统 (Entity Graph Management)**
+#### 实体类型定义
+```python
+ENTITY_TYPES = {
+    "airport": {
+        "attributes": ["code", "name", "location", "capacity", "status"],
+        "relationships": {
+            "uses": ["technology", "system", "vendor"],
+            "located_in": ["region", "country"],
+            "implements": ["standard", "certification"]
+        }
+    },
+    "technology": {
+        "attributes": ["category", "vendor", "version", "specs"],
+        "relationships": {
+            "used_by": ["airport", "system"],
+            "compatible_with": ["technology"],
+            "replaces": ["technology"]
+        }
+    },
+    "vendor": {
+        "attributes": ["name", "country", "specialization", "market_share"],
+        "relationships": {
+            "provides": ["technology", "service"],
+            "competes_with": ["vendor"],
+            "partners_with": ["vendor"]
+        }
+    }
+}
+```
+
+#### 关系类型
+| 关系类型 | 语义 | 反向关系 | 示例 |
+|----------|------|----------|------|
+| **uses** | 使用 | used_by | 深圳机场 uses SITA AODB |
+| **implements** | 实现 | implemented_by | JFK implements ACI EUROPE 2020 |
+| **replaces** | 替换 | replaced_by | H100 replaces A100 |
+| **based_on** | 基于 | basis_for | 数字孿生 based_on BIM 模型 |
+| **compatible_with** | 兼容 | compatible_with | RoCE compatible_with InfiniBand |
+| **partners_with** | 合作 | partners_with | SITA partners_with Huawei |
+
+### 3. **自动化钩子系统 (Automation Hooks)**
+#### 事件注册表
+```python
+HOOK_REGISTRY = {
+    "source_added": [
+        {"callback": "parse_source", "priority": 10},
+        {"callback": "extract_entities", "priority": 9},
+        {"callback": "detect_conflicts", "priority": 8},
+        {"callback": "update_confidence", "priority": 7}
+    ],
+    "page_updated": [
+        {"callback": "check_semantic_change", "priority": 10},
+        {"callback": "update_embeddings", "priority": 9},
+        {"callback": "propagate_relations", "priority": 8},
+        {"callback": "log_change", "priority": 5}
+    ],
+    "query_executed": [
+        {"callback": "record_query_pattern", "priority": 10},
+        {"callback": "evaluate_results", "priority": 8},
+        {"callback": "generate_suggestions", "priority": 5}
+    ]
+}
+```
+
+#### 定时任务调度
+```python
+SCHEDULE_CONFIG = {
+    "daily": {
+        "time": "02:30",
+        "tasks": [
+            "verify_recent_changes",
+            "update_recommendations",
+            "clean_temp_files",
+            "backup_incremental"
+        ]
+    },
+    "weekly": {
+        "time": "03:00",
+        "day": "sunday",
+        "tasks": [
+            "run_lint_check",
+            "decay_confidence_scores",
+            "regenerate_embeddings",
+            "rebuild_search_index"
+        ]
+    },
+    "monthly": {
+        "time": "04:00",
+        "day": 1,  # 每月1日
+        "tasks": [
+            "archive_stale_content",
+            "evaluate_embedding_models",
+            "analyze_growth_trends",
+            "run_security_audit"
+        ]
+    }
+}
+```
+
+### 4. **混合搜索系统 (Hybrid Search System)**
+#### 搜索评分算法
+```python
+def calculate_search_score(page, query, user_context):
+    # 1. 文本相关性 (BM25)
+    text_relevance = bm25_score(page.content, query)
+    
+    # 2. 语义相关性 (嵌入相似度)
+    semantic_relevance = embedding_similarity(page.embedding, query_embedding)
+    
+    # 3. 置信度调整
+    confidence_adjustment = page.confidence ** 2
+    
+    # 4. 时效性调整
+    recency_adjustment = 1.0 / (1 + page.age_days / 180)
+    
+    # 5. 个性化调整
+    personalization = calculate_personalization_score(page, user_context)
+    
+    # 综合评分 (加权)
+    score = (
+        text_relevance * 0.4 +
+        semantic_relevance * 0.4 +
+        confidence_adjustment * 0.15 +
+        recency_adjustment * 0.05 +
+        personalization * 0.1
+    )
+    
+    return score
+```
+
+#### 查询重写策略
+```python
+QUERY_REWRITE_RULES = [
+    # 同义词扩展
+    {"pattern": r"\bgpu\b", "expansion": "gpu OR graphics processing unit OR ai accelerator"},
+    
+    # 技术缩写扩展
+    {"pattern": r"\baodb\b", "expansion": "aodb OR airport operational database"},
+    
+    # 机场代码映射
+    {"pattern": r"\bSZX\b", "expansion": "SZX OR Shenzhen Bao'an International Airport"},
+    {"pattern": r"\bJFK\b", "expansion": "JFK OR New York John F. Kennedy Airport"},
+    
+    # 单位标准化
+    {"pattern": r"(\d+)\s*kw", "expansion": "$1 kW OR $1 kilowatt"},
+    {"pattern": r"(\d+)\s*MW", "expansion": "$1 MW OR $1 megawatt"},
+]
+```
+
+---
+
+## ⚙️ 配置与部署
+
+### 配置文件结构
+```yaml
+# ~/.hermes/ObsidianVault/airport-wiki/config.yaml
+
+llm_wiki:
+  version: "2.1.0"
+  
+  confidence:
+    decay_rate: 0.05  # 每月衰减率
+    min_confidence: 0.05
+    max_confidence: 1.0
+    usage_weight: 0.2
+    sources_weight: 0.15
+  
+  automation:
+    enabled: true
+    check_interval_seconds: 15  # 文件监视间隔
+    max_workers: 3
+    
+  search:
+    hybrid_enabled: true
+    vector_weight: 0.4
+    keyword_weight: 0.4
+    confidence_weight: 0.15
+    recency_weight: 0.05
+    query_expansion: true
+    
+  entities:
+    types: ["airport", "technology", "vendor", "standard", "system"]
+    relation_types: ["uses", "implements", "replaces", "based_on", "compatible_with"]
+    
+  storage:
+    vector_db: "chromadb"
+    doc_store: "filesystem"
+    graph_db: "sqlite"
+    
+  monitoring:
+    metrics_enabled: true
+    alerting_enabled: true
+    log_level: "info"
+```
+
+### 环境变量
+```bash
+# LLM Wiki 核心配置
+export LLM_WIKI_HOME="/home/windy/.hermes/ObsidianVault/airport-wiki"
+export EMBEDDING_MODEL="all-MiniLM-L6-v2"
+export VECTOR_DB_HOST="localhost"
+export VECTOR_DB_PORT=8000
+
+# 自动化钩子
+export HOOKS_ENABLED="true"
+export HOOKS_CHECK_INTERVAL="15"
+export HOOKS_MAX_WORKERS="3"
+
+# 监控和日志
+export LOG_LEVEL="info"
+export METRICS_PORT="9090"
+export ALERT_WEBHOOK="https://hooks.slack.com/services/..."
+```
+
+### 初始化脚本
+```bash
+#!/bin/bash
+# init_llm_wiki_v2.sh
+
+# 1. 检查依赖
+check_dependencies() {
+    echo "检查依赖..."
+    python3 --version >/dev/null 2>&1 || { echo "需要 Python 3.8+"; exit 1; }
+    pip --version >/dev/null 2>&1 || { echo "需要 pip"; exit 1; }
+}
+
+# 2. 安装 Python 包
+install_packages() {
+    echo "安装 Python 包..."
+    pip install -r requirements.txt
+}
+
+# 3. 初始化数据库
+init_databases() {
+    echo "初始化数据库..."
+    python -c "from storage import init_db; init_db()"
+}
+
+# 4. 生成初始嵌入
+generate_initial_embeddings() {
+    echo "生成初始嵌入..."
+    python -c "from embeddings import generate_all_embeddings; generate_all_embeddings()"
+}
+
+# 5. 启动服务
+start_services() {
+    echo "启动服务..."
+    
+    # 启动文件监视服务
+    python -m hooks.file_watcher &
+    
+    # 启动定时任务调度器
+    python -m hooks.scheduler &
+    
+    # 启动监控服务
+    python -m monitoring.metrics_server &
+}
+
+main() {
+    echo "=== LLM Wiki v2 初始化 ==="
+    
+    check_dependencies
+    install_packages
+    init_databases
+    generate_initial_embeddings
+    start_services
+    
+    echo "✅ 初始化完成"
+    echo "监控面板: http://localhost:9090"
+    echo "搜索端点: http://localhost:8000/search"
+}
+
+main "$@"
+```
+
+---
+
+## 🔄 升级与迁移
+
+### 从 v1 升级到 v2
+#### 步骤 1: 备份 v1 数据
+```bash
+# 备份整个 wiki 目录
+tar -czf wiki_v1_backup_$(date +%Y%m%d).tar.gz airport-wiki/
+
+# 导出实体关系
+python -c "from v1_exporter import export_all; export_all('v1_export.json')"
+```
+
+#### 步骤 2: 安装 v2 组件
+```bash
+# 创建新配置目录
+mkdir -p ~/.hermes/ObsidianVault/airport-wiki/concepts/knowledge-management
+
+# 安装 v2 Python 包
+pip install llm-wiki-v2
+
+# 初始化 v2 数据库
+python -m llm_wiki_v2.init --config config.yaml
+```
+
+#### 步骤 3: 迁移数据
+```bash
+# 运行迁移脚本
+python -m llm_wiki_v2.migrate \
+  --v1_path ./airport-wiki \
+  --v2_path ./airport-wiki-v2 \
+  --mode incremental
+```
+
+#### 步骤 4: 验证迁移
+```bash
+# 检查置信度字段
+python -c "from validation import check_migration; check_migration('airport-wiki-v2')"
+
+# 测试搜索功能
+curl -X POST "http://localhost:8000/search" \
+  -H "Content-Type: application/json" \
+  -d '{"query": "GPU cluster power consumption", "limit": 5}'
+```
+
+### 数据迁移策略
+| 数据类型 | v1 格式 | v2 格式 | 迁移方法 |
+|----------|---------|---------|----------|
+| **页面内容** | 纯 Markdown | Markdown + YAML frontmatter | 解析并添加置信度字段 |
+| **实体关系** | 链接（无类型） | 类型化关系 | 提取文本关系并分类 |
+| **嵌入向量** | 无 | 向量数据库 | 重新生成所有嵌入 |
+| **搜索索引** | 文件搜索 | 混合搜索索引 | 重建索引 |
+
+---
+
+## 📊 监控与告警
+
+### 关键性能指标 (KPIs)
+```python
+KPI_CONFIG = {
+    "search": {
+        "response_time_p95": {"threshold": 3000, "unit": "ms"},
+        "success_rate": {"threshold": 0.95, "unit": "%"},
+        "recall_at_5": {"threshold": 0.85, "unit": "%"}
+    },
+    "confidence": {
+        "average_confidence": {"threshold": 0.7, "unit": "score"},
+        "decay_rate": {"threshold": 0.1, "unit": "/month"},
+        "conflict_resolution_rate": {"threshold": 0.9, "unit": "%"}
+    },
+    "automation": {
+        "hook_success_rate": {"threshold": 0.95, "unit": "%"},
+        "processing_time_p95": {"threshold": 5000, "unit": "ms"},
+        "backlog_size": {"threshold": 100, "unit": "items"}
+    }
+}
+```
+
+### 告警规则
+```yaml
+alerts:
+  - name: "search_degradation"
+    condition: "search_response_time_p95 > 3000 OR search_success_rate < 0.95"
+    severity: "critical"
+    actions: ["page_oncall", "rollback_search_config"]
+    
+  - name: "confidence_anomaly"
+    condition: "average_confidence < 0.6 OR decay_rate > 0.15"
+    severity: "high"
+    actions: ["notify_maintainer", "run_verification"]
+    
+  - name: "automation_failure"
+    condition: "hook_success_rate < 0.9 OR backlog_size > 200"
+    severity: "medium"
+    actions: ["log_incident", "restart_workers"]
+```
+
+### 监控仪表板
+- **搜索性能仪表板**：响应时间、命中率、用户满意度
+- **知识质量仪表板**：平均置信度、冲突数量、更新频率
+- **系统健康仪表板**：自动化成功率、存储使用率、错误率
+
+---
+
+## 🛠️ 故障排除
+
+### 常见问题及解决方法
+| 问题 | 症状 | 解决方案 |
+|------|------|----------|
+| **置信度不衰减** | 页面置信度长期不变 | 检查定时任务是否运行；验证衰减算法参数 |
+| **搜索结果差** | 相关页面排名靠后 | 调整搜索权重；重新生成嵌入；检查索引 |
+| **自动化钩子失败** | 文件变更未触发处理 | 验证文件监视配置；检查权限；查看日志 |
+| **实体关系缺失** | 页面无关系链接 | 运行实体提取；检查关系检测规则 |
+| **嵌入生成失败** | 页面无嵌入向量 | 检查模型加载；验证文本编码；查看错误日志 |
+
+### 诊断命令
+```bash
+# 检查系统状态
+python -m llm_wiki_v2.status --full
+
+# 查看日志
+tail -f ~/.hermes/logs/llm_wiki.log
+
+# 手动触发维护任务
+python -m hooks.runner --task weekly_maintenance
+
+# 检查数据库完整性
+python -c "from storage import verify_integrity; verify_integrity()"
+
+# 重置错误状态
+python -m llm_wiki_v2.reset --component hooks
+```
+
+---
+
+## 🔮 未来发展方向
+
+### 近期计划 (1-3个月)
+- **智能答案生成**：基于查询自动生成综合答案
+- **预测性维护**：基于历史模式预测知识老化
+- **多模态支持**：图像、图表等非文本内容处理
+- **用户行为分析**：优化搜索和推荐系统
+
+### 中期计划 (3-12个月)
+- **跨wiki知识同步**：多个wiki之间的知识共享
+- **自适应学习**：系统自动调整参数和规则
+- **自然语言更新**：用户用自然语言编辑知识
+- **实时协作**：多用户同时编辑和注释
+
+### 长期愿景 (1年以上)
+- **自主知识管理**：系统完全自主维护和优化知识库
+- **预测性内容创建**：基于趋势预测自动创建新内容
+- **智能决策支持**：基于知识库提供决策建议
+- **认知增强**：与人类思维深度协同的知识系统
+
+---
+
+## 📚 相关资源
+
+### 官方文档
+- [[SCHEMA.md]] - 架构定义和设计规范
+- [[concepts/knowledge-management/automation-hooks.md]] - 自动化钩子详细实现
+- [[concepts/knowledge-management/knowledge-lifecycle.md]] - 知识生命周期管理
+- [[concepts/knowledge-management/quality-control.md]] - 质量控制机制
+- [[concepts/knowledge-management/knowledge-graph.md]] - 实体图管理
+- [[concepts/knowledge-management/hybrid-search.md]] - 混合搜索系统
+
+### 工具和库
+- **向量数据库**: ChromaDB, Qdrant, Weaviate
+- **嵌入模型**: all-MiniLM-L6-v2, BGE, OpenAI embeddings
+- **搜索引擎**: Elasticsearch, Meilisearch, Typesense
+- **监控**: Prometheus, Grafana, OpenTelemetry
+
+### 参考文献
+1. Karpathy, A. "LLM: A Personal Knowledge Base"
+2. Luhmann, N. "Zettelkasten Method"
+3. Ahrens, S. "How to Take Smart Notes"
+4. Vannevar Bush, "As We May Think"
+
+---
+
+> **版本**: v2.1.0 | **最后更新**: 2026-04-13  
+> **维护状态**: 活跃 | **支持**: 用户文档 + 技术支持论坛  
+> **注意**: 本系统持续演进，建议定期查看相关文档获取最新信息。

airport-wiki/concepts/knowledge-management/quality-control.md

@@ -0,0 +1,616 @@
+---
+title: 质量控制与自我纠正机制
+created: 2026-04-13
+updated: 2026-04-13
+type: concept
+tags: [knowledge-management, quality-control, self-correction, validation]
+confidence: 0.9
+sources_count: 4
+last_confirmed: 2026-04-13
+status: active
+relationships:
+  - target: automation-hooks.md
+    type: integrates-with
+    detail: "质量检查触发事件"
+    confidence: 0.95
+  - target: knowledge-management/knowledge-lifecycle.md
+    type: informs
+    detail: "置信度评估依据"
+    confidence: 0.9
+  - target: knowledge-management/knowledge-graph.md
+    type: validates
+    detail: "关系一致性检查"
+    confidence: 0.85
+  - target: hybrid-search.md
+    type: improves
+    detail: "搜索结果质量提升"
+    confidence: 0.8
+---
+
+# 🔍 质量控制与自我纠正机制
+
+为机场智能化 wiki 建立**多层次质量验证**和**自动纠错**系统，确保技术参数准确、内容一致、关系完整。通过规则检查、语义验证和用户反馈，实现持续质量改进。
+
+> **质量目标**：零技术参数错误，内容一致性 >95%，关系完整性 >90%，用户满意度 >85%。
+
+---
+
+## 🏗️ 质量框架层次
+
+### 层次 1: **语法与格式检查** (Syntax & Format)
+| 检查项 | 规则 | 自动修复 | 严重性 |
+|--------|------|----------|--------|
+| **Markdown 语法** | 链接格式、标题层级、列表 | ✅ 自动修复 | 低 |
+| **YAML 前端元数据** | 必需字段、类型验证 | ✅ 自动修复 | 中 |
+| **文件命名规范** | 小写、连字符、无空格 | ✅ 自动修复 | 低 |
+| **编码与换行** | UTF-8, LF 换行 | ✅ 自动修复 | 低 |
+
+### 层次 2: **内容一致性检查** (Content Consistency)
+| 检查项 | 规则 | 自动修复 | 严重性 |
+|--------|------|----------|--------|
+| **技术参数一致性** | 同一参数多源一致 | ⚠️ 标记冲突 | 高 |
+| **单位统一性** | kW vs MW, GB vs GiB | ✅ 自动转换 | 中 |
+| **术语标准化** | 统一技术术语 | ✅ 建议替换 | 中 |
+| **日期格式** | ISO 8601 标准 | ✅ 自动转换 | 低 |
+
+### 层次 3: **语义与逻辑检查** (Semantic & Logic)
+| 检查项 | 规则 | 自动修复 | 严重性 |
+|--------|------|----------|--------|
+| **事实冲突检测** | 矛盾陈述识别 | ❌ 人工审核 | 高 |
+| **因果关系验证** | 逻辑链完整性 | ⚠️ 标记缺失 | 中 |
+| **数值合理性** | 功率/容量范围检查 | ⚠️ 标记异常 | 高 |
+| **时间线一致性** | 事件顺序验证 | ⚠️ 标记矛盾 | 中 |
+
+### 层次 4: **关系完整性检查** (Relationship Integrity)
+| 检查项 | 规则 | 自动修复 | 严重性 |
+|--------|------|----------|--------|
+| **死链检测** | 内部链接有效性 | ✅ 自动修复 | 中 |
+| **孤立页面** | 无入链页面识别 | ⚠️ 标记孤立 | 低 |
+| **循环引用** | 循环依赖检测 | ⚠️ 标记循环 | 中 |
+| **关系对称性** | 双向关系验证 | ✅ 自动修复 | 中 |
+
+---
+
+## 🔧 自动检查规则库
+
+### 技术参数验证规则
+```python
+TECHNICAL_RULES = {
+    "power_consumption": {
+        "pattern": r"(\d+(?:\.\d+)?)\s*(kW|MW|W)",
+        "validation": lambda value, unit: (
+            # 数据中心功率范围检查
+            if unit == "MW" and value > 100:
+                return False, "数据中心功率超过100MW需验证"
+            elif unit == "kW" and value < 1:
+                return False, "功率低于1kW可能错误"
+            else:
+                return True, ""
+        ),
+        "auto_correct": lambda value, unit: (
+            # 自动单位转换 kW → MW
+            if unit == "kW" and value >= 1000:
+                return f"{value/1000:.2f} MW"
+            else:
+                return None
+        )
+    },
+    
+    "temperature_range": {
+        "pattern": r"(\d+(?:\.\d+)?)\s*°?[CF]",
+        "validation": lambda value, unit: (
+            # 数据中心温度范围检查
+            if unit == "C" and (value < 18 or value > 27):
+                return False, "数据中心温度超出推荐范围 (18-27°C)"
+            elif unit == "F" and (value < 64 or value > 81):
+                return False, "数据中心温度超出推荐范围 (64-81°F)"
+            else:
+                return True, ""
+        ),
+        "auto_correct": lambda value, unit: (
+            # 温度单位转换
+            if unit == "F":
+                return f"{(value-32)*5/9:.1f}°C"
+            else:
+                return None
+        )
+    },
+    
+    "rack_power_density": {
+        "pattern": r"(\d+(?:\.\d+)?)\s*(kW/rack|kW per rack)",
+        "validation": lambda value, unit: (
+            # 机架功率密度检查
+            if value > 50:
+                return False, "机架功率密度超过50kW/rack需液冷"
+            elif value < 1:
+                return False, "机架功率密度低于1kW/rack可能错误"
+            else:
+                return True, ""
+        )
+    }
+}
+```
+
+### 一致性检查规则
+```python
+CONSISTENCY_RULES = {
+    "vendor_product_names": {
+        "mappings": {
+            "NVIDIA": ["nvidia", "Nvidia", "NVIDIA Corporation"],
+            "Intel": ["intel", "Intel Corporation", "Intel Corp"],
+            "华为": ["Huawei", "huawei", "华为技术有限公司"],
+            "曙光": ["Sugon", "曙光信息", "中科曙光"]
+        },
+        "action": "standardize"  # 标准化为规范名称
+    },
+    
+    "date_formats": {
+        "patterns": [
+            r"\d{4}-\d{2}-\d{2}",  # ISO 8601
+            r"\d{2}/\d{2}/\d{4}",   # MM/DD/YYYY
+            r"\d{4}年\d{1,2}月\d{1,2}日"  # 中文日期
+        ],
+        "target_format": "%Y-%m-%d",  # 统一为 ISO 8601
+        "action": "convert"
+    },
+    
+    "capacity_units": {
+        "mappings": {
+            "GB": ["gb", "gigabyte", "gigabytes"],
+            "TB": ["tb", "terabyte", "terabytes"],
+            "PB": ["pb", "petabyte", "petabytes"],
+            "GiB": ["gib", "gibibyte"],
+            "TiB": ["tib", "tebibyte"]
+        },
+        "action": "standardize"
+    }
+}
+```
+
+---
+
+## 🛠️ 自我纠正机制
+
+### 1. **自动修复流程**
+```python
+def auto_correction_pipeline(content: str) -> Tuple[str, List[Correction]]:
+    """
+    自动纠正管道：多层修复策略
+    返回: (修正后内容, 修正记录列表)
+    """
+    corrections = []
+    
+    # 第1层：语法修复
+    content, syntax_fixes = fix_markdown_syntax(content)
+    corrections.extend(syntax_fixes)
+    
+    # 第2层：格式修复
+    content, format_fixes = fix_yaml_frontmatter(content)
+    corrections.extend(format_fixes)
+    
+    # 第3层：单位标准化
+    content, unit_fixes = standardize_units(content)
+    corrections.extend(unit_fixes)
+    
+    # 第4层：术语标准化
+    content, term_fixes = standardize_terminology(content)
+    corrections.extend(term_fixes)
+    
+    # 第5层：链接修复
+    content, link_fixes = fix_broken_links(content)
+    corrections.extend(link_fixes)
+    
+    return content, corrections
+```
+
+### 2. **冲突解决策略**
+```python
+def resolve_content_conflict(existing_content: str, 
+                            new_content: str,
+                            conflict_type: str) -> ResolutionResult:
+    """
+    解决内容冲突的策略
+    """
+    
+    if conflict_type == "factual_conflict":
+        # 事实冲突：基于置信度选择
+        existing_confidence = calculate_confidence(existing_content)
+        new_confidence = calculate_confidence(new_content)
+        
+        if new_confidence > existing_confidence * 1.2:
+            # 新内容置信度显著更高
+            return ResolutionResult.REPLACE
+        elif existing_confidence > new_confidence * 1.2:
+            # 现有内容置信度显著更高
+            return ResolutionResult.KEEP
+        else:
+            # 置信度相近：标记为待审核
+            return ResolutionResult.FLAG_FOR_REVIEW
+    
+    elif conflict_type == "complementary_info":
+        # 互补信息：合并
+        return ResolutionResult.MERGE
+    
+    elif conflict_type == "version_update":
+        # 版本更新：建立 superseded_by 关系
+        return ResolutionResult.SUPERSEDE
+    
+    elif conflict_type == "formatting_only":
+        # 仅格式差异：保留更好格式
+        return ResolutionResult.KEEP_BETTER_FORMAT
+    
+    else:
+        # 未知冲突类型：人工审核
+        return ResolutionResult.MANUAL_REVIEW
+```
+
+### 3. **质量评分系统**
+```python
+class QualityScorer:
+    """质量评分系统"""
+    
+    def __init__(self):
+        self.weights = {
+            "technical_accuracy": 0.30,
+            "consistency": 0.25,
+            "completeness": 0.20,
+            "recency": 0.15,
+            "source_credibility": 0.10
+        }
+    
+    def score_page(self, page: Page) -> QualityScore:
+        """计算页面质量分数 (0-100)"""
+        
+        scores = {}
+        
+        # 1. 技术准确性
+        scores["technical_accuracy"] = self._score_technical_accuracy(page)
+        
+        # 2. 一致性
+        scores["consistency"] = self._score_consistency(page)
+        
+        # 3. 完整性
+        scores["completeness"] = self._score_completeness(page)
+        
+        # 4. 时效性
+        scores["recency"] = self._score_recency(page)
+        
+        # 5. 来源可信度
+        scores["source_credibility"] = self._score_source_credibility(page)
+        
+        # 加权总分
+        total_score = sum(
+            score * self.weights[metric]
+            for metric, score in scores.items()
+        )
+        
+        return QualityScore(
+            total=total_score,
+            breakdown=scores,
+            grade=self._assign_grade(total_score)
+        )
+    
+    def _assign_grade(self, score: float) -> str:
+        """分配质量等级"""
+        if score >= 90:
+            return "A+"
+        elif score >= 80:
+            return "A"
+        elif score >= 70:
+            return "B"
+        elif score >= 60:
+            return "C"
+        elif score >= 50:
+            return "D"
+        else:
+            return "F"
+```
+
+---
+
+## 📊 质量监控仪表板
+
+### 关键质量指标 (KQIs)
+```python
+KQI_METRICS = {
+    "technical_accuracy_rate": {
+        "description": "技术参数准确率",
+        "calculation": "accurate_params / total_params",
+        "target": ">98%",
+        "weight": 0.35
+    },
+    
+    "consistency_score": {
+        "description": "内容一致性评分",
+        "calculation": "average_consistency_score",
+        "target": ">95",
+        "weight": 0.25
+    },
+    
+    "completeness_index": {
+        "description": "页面完整性指数",
+        "calculation": "filled_sections / total_sections",
+        "target": ">90%",
+        "weight": 0.20
+    },
+    
+    "freshness_score": {
+        "description": "内容新鲜度评分",
+        "calculation": "weighted_average(recency)",
+        "target": ">85",
+        "weight": 0.10
+    },
+    
+    "user_satisfaction": {
+        "description": "用户满意度",
+        "calculation": "positive_feedback / total_feedback",
+        "target": ">85%",
+        "weight": 0.10
+    }
+}
+```
+
+### 质量趋势分析
+```python
+def analyze_quality_trends(time_period: str = "monthly"):
+    """
+    分析质量趋势
+    """
+    
+    # 获取历史数据
+    history = get_quality_history(time_period)
+    
+    trends = {}
+    
+    for metric in KQI_METRICS:
+        values = [h[metric] for h in history]
+        
+        # 计算趋势
+        if len(values) >= 2:
+            slope = calculate_slope(values)
+            trend = "improving" if slope > 0.01 else "declining" if slope < -0.01 else "stable"
+            
+            # 检测异常点
+            anomalies = detect_anomalies(values)
+            
+            trends[metric] = {
+                "current": values[-1],
+                "trend": trend,
+                "slope": slope,
+                "anomalies": anomalies,
+                "target": KQI_METRICS[metric]["target"]
+            }
+    
+    # 综合质量指数
+    composite_score = calculate_composite_quality_index(trends)
+    
+    return {
+        "period": time_period,
+        "composite_score": composite_score,
+        "trends": trends,
+        "recommendations": generate_quality_recommendations(trends)
+    }
+```
+
+---
+
+## 🚨 异常检测与告警
+
+### 异常检测规则
+```python
+ANOMALY_RULES = {
+    "sudden_confidence_drop": {
+        "condition": "confidence_change < -0.2",
+        "severity": "high",
+        "action": "investigate_source_changes"
+    },
+    
+    "technical_parameter_outlier": {
+        "condition": "parameter_value outside 3σ",
+        "severity": "critical",
+        "action": "verify_with_primary_source"
+    },
+    
+    "multiple_conflicts_detected": {
+        "condition": "conflict_count > 3",
+        "severity": "medium",
+        "action": "initiate_review_process"
+    },
+    
+    "orphaned_page_created": {
+        "condition": "incoming_links == 0 AND outgoing_links > 5",
+        "severity": "low",
+        "action": "suggest_relationships"
+    },
+    
+    "stale_content_alert": {
+        "condition": "last_updated > 180 days AND confidence > 0.7",
+        "severity": "medium",
+        "action": "schedule_refresh"
+    }
+}
+```
+
+### 告警处理流程
+```python
+def handle_quality_alert(alert: Alert):
+    """
+    处理质量告警
+    """
+    
+    # 1. 记录告警
+    log_alert(alert)
+    
+    # 2. 根据严重性采取行动
+    if alert.severity == "critical":
+        # 立即处理：暂停相关页面，通知维护者
+        suspend_page(alert.page_id)
+        notify_maintainer(alert, priority="high")
+        
+        # 启动调查
+        investigation = investigate_alert(alert)
+        
+        # 根据调查结果采取行动
+        if investigation["requires_manual_fix"]:
+            create_maintenance_task(alert)
+        else:
+            apply_auto_fix(alert, investigation)
+    
+    elif alert.severity == "high":
+        # 高优先级：标记为待处理，24小时内处理
+        create_maintenance_task(alert, due_in_hours=24)
+        notify_maintainer(alert, priority="medium")
+    
+    elif alert.severity == "medium":
+        # 中优先级：加入待办队列，72小时内处理
+        create_maintenance_task(alert, due_in_hours=72)
+    
+    elif alert.severity == "low":
+        # 低优先级：批量处理，每周统一处理
+        queue_for_batch_processing(alert)
+    
+    # 3. 更新告警状态
+    update_alert_status(alert, "handled")
+```
+
+---
+
+## 🔄 持续改进循环
+
+### PDCA 循环 (Plan-Do-Check-Act)
+```python
+def quality_improvement_cycle():
+    """
+    质量持续改进循环
+    """
+    
+    while True:
+        # 1. PLAN: 分析质量数据，制定改进计划
+        quality_report = analyze_quality_trends("weekly")
+        improvement_plan = create_improvement_plan(quality_report)
+        
+        # 2. DO: 执行改进措施
+        implemented_changes = execute_improvement_plan(improvement_plan)
+        
+        # 3. CHECK: 评估改进效果
+        effect_measurement = measure_improvement_effect(implemented_changes)
+        
+        # 4. ACT: 标准化成功措施，调整失败措施
+        if effect_measurement["successful"]:
+            standardize_successful_changes(implemented_changes)
+        else:
+            adjust_failed_changes(implemented_changes, effect_measurement)
+        
+        # 等待下一周期
+        time.sleep(7 * 24 * 3600)  # 每周一次
+```
+
+### A/B 测试框架
+```python
+def run_quality_ab_test(test_name: str, variant_a: Dict, variant_b: Dict):
+    """
+    运行质量改进A/B测试
+    """
+    
+    # 1. 随机分配页面到测试组
+    group_a, group_b = random_split_pages(test_name, 50)
+    
+    # 2. 应用不同变体
+    apply_variant(group_a, variant_a)
+    apply_variant(group_b, variant_b)
+    
+    # 3. 收集指标
+    metrics_a = collect_metrics(group_a, duration_days=14)
+    metrics_b = collect_metrics(group_b, duration_days=14)
+    
+    # 4. 统计分析
+    result = statistical_analysis(metrics_a, metrics_b)
+    
+    # 5. 决定获胜变体
+    if result["significant"] and result["winner"] == "A":
+        winning_variant = variant_a
+    elif result["significant"] and result["winner"] == "B":
+        winning_variant = variant_b
+    else:
+        winning_variant = None  # 无显著差异
+    
+    # 6. 记录测试结果
+    log_ab_test_result(test_name, result, winning_variant)
+    
+    return {
+        "test_name": test_name,
+        "result": result,
+        "winning_variant": winning_variant,
+        "recommendation": "implement" if winning_variant else "no_change"
+    }
+```
+
+---
+
+## 📋 质量检查清单
+
+### 每日检查
+- [ ] 语法检查报告（自动）
+- [ ] 新内容质量评分（自动）
+- [ ] 冲突检测（自动）
+- [ ] 链接有效性检查（自动）
+
+### 每周检查
+- [ ] 技术参数一致性验证（半自动）
+- [ ] 关系完整性检查（自动）
+- [ ] 质量趋势分析（自动）
+- [ ] 用户反馈分析（半自动）
+
+### 每月检查
+- [ ] 全面质量审计（手动）
+- [ ] 规则库更新评估（手动）
+- [ ] 自我纠正效果评估（半自动）
+- [ ] 质量改进计划制定（手动）
+
+### 季度检查
+- [ ] 质量框架评估（手动）
+- [ ] 用户满意度调查（手动）
+- [ ] 基准对比分析（半自动）
+- [ ] 战略调整（手动）
+
+---
+
+## 🚀 实施路线图
+
+### 阶段 1：基础检查（当前）
+- ✅ 语法和格式检查
+- ✅ 基本一致性验证
+- 🔄 自动修复简单问题
+- 🔄 质量评分基础框架
+
+### 阶段 2：智能验证（2-4周）
+- 🔄 技术参数验证规则
+- 🔄 语义冲突检测
+- 🔄 自动冲突解决策略
+- 🔄 质量监控仪表板
+
+### 阶段 3：自我纠正（1-2月）
+- 🔄 多层修复管道
+- 🔄 异常检测和告警
+- 🔄 用户反馈集成
+- 🔄 A/B测试框架
+
+### 阶段 4：持续改进（未来）
+- 🔄 自适应质量规则
+- 🔄 预测性质量维护
+- 🔄 跨wiki质量同步
+- 🔄 自主质量优化
+
+---
+
+## 📚 相关文档
+
+- [[automation-hooks.md]] - 质量检查触发事件
+- [[knowledge-management/knowledge-lifecycle.md]] - 置信度评估依据
+- [[knowledge-management/knowledge-graph.md]] - 关系一致性检查
+- [[hybrid-search.md]] - 搜索结果质量提升
+- [[wiki-backup-recovery.md]] - 质量问题的回滚机制
+
+---
+
+> **状态**: 基础语法检查和一致性验证已实现。下一步：集成技术参数验证和冲突检测。最后更新：2026-04-13。