Building and Evaluating Advanced RAG Applications

DeepLearning.AI 课程学习笔记

课程来源：DeepLearning.AI Short Course
合作方：TruEra & LlamaIndex
课程时长：1小时55分钟
授课导师：Jerry Liu（LlamaIndex CEO）、Anupam Datta（Snowflake AI研究负责人）
课程链接：https://www.deeplearning.ai/short-courses/building-evaluating-advanced-rag/

1. 课程概述

1.1 课程背景

RAG（检索增强生成）是当前LLM应用最流行的架构之一，能够将LLM与企业私有数据、领域知识有效整合。然而，基础RAG存在检索质量不稳定、上下文碎片化等问题。

1.2 课程核心目标

掌握高级检索技术：Sentence-window retrieval 和 Auto-merging retrieval
建立评估体系：RAG三元组评估指标
迭代优化方法：通过TruLens框架进行实验追踪和优化

1.3 课程大纲

课时	内容	时长
Introduction	课程介绍与RAG概述	4分钟
Advanced RAG Pipeline	高级RAG流程架构	15分钟
RAG Triad of Metrics	三大评估指标详解	42分钟
Sentence-Window Retrieval	句子窗口检索技术	29分钟
Auto-Merging Retrieval	自动合并检索技术	21分钟
Conclusion	总结与展望	1分钟

2. RAG架构详解

2.1 RAG核心原理

用户问题 → 检索模块 → 上下文组装 → LLM生成 → 回答输出

RAG的核心价值： - 解决LLM知识时效性问题（可接入最新数据） - 解决LLM私有知识缺失问题（可接入企业文档） - 减少幻觉，提升回答准确性

2.2 基础RAG组件

┌─────────────────────────────────────────────────────────────────┐
│                        RAG Pipeline                              │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐  │
│  │ Document  │ →  │ parsing  │ →  │ Chunking │ →  │Embedding │  │
│  │ Loading  │    │          │    │          │    │          │  │
│  └──────────┘    └──────────┘    └──────────┘    └──────────┘  │
│                                                ↓                 │
│  ┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐  │
│  │  Response│ ←  │  LLM     │ ←  │ Context  │ ←  │Retrieval │  │
│  │ Output   │    │ Generation│   │ Assembly │    │  Query   │  │
│  └──────────┘    └──────────┘    └──────────┘    └──────────┘  │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

2.3 基础RAG的问题

问题类型	症状表现	根本原因
检索粒度冲突	细粒度检索不准，粗粒度上下文有噪声	"检索单元"与"生成单元"不匹配
上下文碎片化	跨段落问题回答不完整	节点间缺少层级关系
语义漂移	语义相似的句子被分割到不同chunk	固定大小切分无视语义边界

3. 高级检索技术对比

3.1 Sentence-Window Retrieval（句子窗口检索）

3.1.1 技术原理

核心思想：实现"检索粒度"与"生成粒度"的解耦

索引阶段：
┌────────────────────────────────────────────────────────┐
│ 原文档："机器学习是AI的子领域..."                          │
│         "它包括监督学习和无监督学习..."                      │
│         "神经网络是深度学习的基础..."                       │
├────────────────────────────────────────────────────────┤
│ SentenceWindowNodeParser 解析为单句节点                    │
│ 节点1: "机器学习是AI的子领域"                              │
│        metadata.window = "机器学习是AI的子领域..."          │
│        "它包括监督学习和无监督学习..."                       │
│ 节点2: "它包括监督学习和无监督学习"                          │
│        metadata.window = "机器学习是AI的子领域..."          │
│        "它包括监督学习和无监督学习..."                       │
│        "神经网络是深度学习的基础..."                        │
│ 节点3: "神经网络是深度学习的基础"                           │
│        metadata.window = "它包括监督学习和无监督学习..."     │
│        "神经网络是深度学习的基础"                           │
└────────────────────────────────────────────────────────┘
                                    ↓
                         仅对单句生成embedding
                                    ↓
                        存入VectorStoreIndex

3.1.2 检索流程

用户查询 → 生成query embedding → Top-k检索单句节点
                ↓
    MetadataReplacementPostProcessor
                ↓
    将单句替换为metadata["window"]中的完整上下文
                ↓
         送入LLM生成回答

3.1.3 适用场景

✅ 大型文档库检索
✅ 需要细粒度匹配的场景
✅ 关键词驱动但需要上下文理解的查询

3.1.4 优缺点

优点	缺点
检索精准（单句匹配）	索引节点数量多，存储开销大
上下文完整（窗口扩展）	window_size参数需调优
减少幻觉（上下文自洽）	不适合高度结构化文档

3.2 Auto-Merging Retrieval（自动合并检索）

3.2.1 技术原理

核心思想：利用文档层级结构，动态合并相关叶子节点

┌─────────────────────────────────────────────────────────────┐
│                  HierarchicalNodeParser                      │
│                    (层级节点解析器)                            │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│   Level 1 (2048 tokens)  ┌─────────────────────────┐       │
│                          │     父节点 (Parent)      │       │
│                          │  "完整的章节内容..."       │       │
│                          └────────────┬────────────┘       │
│                                       │                    │
│                          ┌────────────┴────────────┐        │
│                          │                         │        │
│   Level 2 (512 tokens)   ▼           ┌─────────────┐       │
│                          ┌─────────┐ │             │       │
│                          │ 子节点A  │ │   子节点B   │       │
│                          └────┬────┘ └──────┬──────┘       │
│                               │             │              │
│                          ┌────┴────┐    ┌────┴────┐         │
│   Level 3 (128 tokens)   │ 叶子节点1│    │ 叶子节点2│         │
│                          │ 小段落   │    │ 小段落   │         │
│                          └─────────┘    └─────────┘         │
│                                                              │
└─────────────────────────────────────────────────────────────┘
                                    ↓
                   仅对叶子节点生成embedding并索引
                                    ↓
                          检索时检查归属比例

3.2.2 合并逻辑

# 伪代码：AutoMergingRetriever合并逻辑
for parent_node in retrieved_leaf_nodes.parents:
    children_count = len(parent_node.children)
    retrieved_children = [c for c in children_count if c in retrieved]

    ratio = len(retrieved_children) / children_count

    # 如果检索到的子节点占父节点的多数，则合并为父节点
    if ratio > simple_ratio_thresh:  # 默认0.5
        delete_children_from_result()
        add_parent_to_result()

3.2.3 适用场景

✅ 长文档问答系统
✅ 需要跨段落综合理解的查询
✅ 文档有明确层级结构的场景

3.2.4 优缺点

优点	缺点
自动适应不同粒度需求	需要定义层级结构
减少上下文长度	合并阈值需调优
保持文档结构完整性	构建成本较高

3.3 技术对比总结

维度	Sentence-Window	Auto-Merging
切分策略	单句切分+元数据窗口	层级切分（多级chunk）
检索单元	单句	叶子节点
生成单元	扩展窗口上下文	合并后父节点
最佳场景	细粒度精准匹配	层级文档理解
实现复杂度	中等	较高
存储开销	中等	较高（存储多级节点）

4. RAG评估方法论

4.1 RAG Triad（三元组评估框架）

TruLens提出的RAG三元组是评估RAG系统的核心方法论：

┌────────────────────────────────────────────────────────────────┐
│                     RAG Triad（三元组）                         │
│                                                                │
│                      ┌─────────────┐                           │
│                      │   Query     │                           │
│                      │   用户查询   │                           │
│                      └──────┬──────┘                           │
│                             │                                  │
│          ┌──────────────────┼──────────────────┐              │
│          │                  │                  │              │
│          ▼                  ▼                  ▼              │
│   ┌─────────────┐   ┌─────────────┐   ┌─────────────┐        │
│   │  Context    │   │Groundedness │   │   Answer    │        │
│   │ Relevance   │   │ (事实基础性) │   │ Relevance   │        │
│   │(上下文相关性)│   │             │   │(答案相关性)  │        │
│   └─────────────┘   └──────┬──────┘   └─────────────┘        │
│          ↑                  │                  ▲                │
│          │                  │                  │                │
│   ┌──────┴──────┐    ┌──────┴──────┐    ┌──────┴──────┐        │
│   │   检索器    │    │  LLM响应    │    │  原始查询   │        │
│   │   输出      │    │             │    │             │        │
│   └─────────────┘    └─────────────┘    └─────────────┘        │
│                                                                │
└────────────────────────────────────────────────────────────────┘

4.2 三大评估指标详解

4.2.1 Context Relevance（上下文相关性）

评估目标：检索到的上下文与用户查询的相关程度

评分标准：0.0 - 1.0
合格阈值：≥ 0.7

评估方法：
1. 分析每个检索到的chunk与query的语义匹配度
2. 检查上下文是否覆盖查询所需信息
3. 识别冗余或无关的检索结果

4.2.2 Groundedness（事实基础性）

评估目标：LLM生成的答案是否严格基于检索到的上下文

评分标准：0.0 - 1.0
合格阈值：≥ 0.8

评估方法：
1. 提取响应中的每个主张(Claim)
2. 在上下文中为每个主张查找证据支持
3. 计算有证据支持的主张占比

这是检测幻觉(Hallucination)的关键指标！

4.2.3 Answer Relevance（答案相关性）

评估目标：最终响应是否有助于回答原始问题

评分标准：0.0 - 1.0
合格阈值：≥ 0.75

评估方法：
1. 检查答案是否直接回应查询意图
2. 评估回答的完整性和有用性
3. 识别信息缺失或答非所问的情况

4.3 TruLens评估框架使用

4.3.1 安装与配置

pip install trulens trulens-providers-litellm

4.3.2 基础使用示例

from trulens import Tru
from trulens.feedback import Feedback, Groundedness, AnswerRelevance, ContextRelevance
from trulens.providers.litellm import LiteLLM

# 初始化
tru = Tru()

# 定义评估函数
grounded = Groundedness(provider=LiteLLM(model="gpt-3.5-turbo"))
f_groundedness = Feedback(grounded.groundedness_measure).on_output()

answer_relevance = AnswerRelevance(provider=LiteLLM(model="gpt-3.5-turbo"))
f_answer_relevance = Feedback(answer_relevance.relevance).on_input_output()

context_relevance = ContextRelevance(provider=LiteLLM(model="gpt-3.5-turbo"))
f_context_relevance = Feedback(context_relevance.relevance).on_input()

# 组合评估
feedbacks = [f_groundedness, f_answer_relevance, f_context_relevance]

# 应用到RAG系统
tru_rag = tru.RAG(
    app=your_rag_app,
    feedbacks=feedbacks,
    app_id="my-rag-app"
)

4.3.3 MLflow集成（2025年新特性）

import mlflow
from mlflow.genai.scorers.trulens import Groundedness, AnswerRelevance, ContextRelevance

# 直接调用scorer
scorer = Groundedness(model="openai:/gpt-4o-mini")
feedback = scorer(
    inputs="What is MLflow?",
    outputs="MLflow is an open-source platform for ML workflows.",
    expectations={"context": "MLflow is an ML platform for tracking experiments..."}
)
print(feedback.value)  # "yes" or "no"
print(feedback.metadata["score"])  # 0.85

5. 关键代码示例

5.1 Sentence-Window检索完整实现

from llama_index.core.node_parser import SentenceWindowNodeParser
from llama_index.core.postprocessor import MetadataReplacementPostProcessor
from llama_index.core import VectorStoreIndex, Settings
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
from llama_index.llms.openai import OpenAI

# 1. 创建句子窗口解析器
node_parser = SentenceWindowNodeParser.from_defaults(
    window_size=3,  # 前后各3个句子
    window_metadata_key="window",
    original_text_metadata_key="original_text",
)

# 2. 配置模型
llm = OpenAI(model="gpt-3.5-turbo", temperature=0.1)
embed_model = HuggingFaceEmbedding(
    model_name="sentence-transformers/all-mpnet-base-v2",
    max_length=512
)
Settings.llm = llm
Settings.embed_model = embed_model

# 3. 解析文档
nodes = node_parser.get_nodes_from_documents(documents)

# 4. 构建索引
sentence_index = VectorStoreIndex(nodes)

# 5. 配置后处理器
postprocessor = MetadataReplacementPostProcessor(
    target_metadata_key="window"
)

# 6. 创建查询引擎
query_engine = sentence_index.as_query_engine(
    similarity_top_k=2,
    node_postprocessors=[postprocessor]
)

# 7. 查询
response = query_engine.query("What is machine learning?")

5.2 Auto-Merging检索完整实现

from llama_index.core.node_parser import HierarchicalNodeParser, get_leaf_nodes
from llama_index.core.storage.docstore import SimpleDocumentStore
from llama_index.core import VectorStoreIndex, StorageContext
from llama_index.core.retrievers import AutoMergingRetriever
from llama_index.core.query_engine import RetrieverQueryEngine
from llama_index.llms.openai import OpenAI

# 1. 创建层级解析器（默认三层：2048 → 512 → 128）
node_parser = HierarchicalNodeParser.from_defaults()
nodes = node_parser.get_nodes_from_documents(documents)

# 2. 分离叶子节点和根节点
leaf_nodes = get_leaf_nodes(nodes)

# 3. 构建存储上下文
docstore = SimpleDocumentStore()
docstore.add_documents(nodes)
storage_context = StorageContext.from_defaults(docstore=docstore)

# 4. 构建向量索引（仅索引叶子节点）
base_index = VectorStoreIndex(
    leaf_nodes,
    storage_context=storage_context,
)

# 5. 配置Auto-Merging检索器
base_retriever = base_index.as_retriever(similarity_top_k=6)
retriever = AutoMergingRetriever(
    base_retriever,
    storage_context,
    simple_ratio_thresh=0.5,  # 合并阈值
    verbose=True
)

# 6. 创建查询引擎
query_engine = RetrieverQueryEngine.from_args(retriever)

# 7. 查询
response = query_engine.query("What are the key concepts of RLHF?")

5.3 TruLens评估集成

from trulens.apps.langchain import TruChain

# 创建带评估的RAG Chain
tru_chain = TruChain(
    chain,
    app_id="RAG-App-v1",
    feedbacks=[
        # Groundedness: 答案是否基于上下文
        Feedback(grounded.groundedness_measure)
            .on_output()
            .aggregate(grounded.grounded_statements),

        # Answer Relevance: 答案与问题的相关性
        Feedback(answer_relevance.relevance)
            .on_input_output(),

        # Context Relevance: 上下文与问题的相关性
        Feedback(context_relevance.relevance)
            .on_input()
    ]
)

# 查询并自动评估
with tru_chain as recording:
    response = chain.invoke({"query": "What is LangChain?"})

# 查看评估结果
print(tru.get_leaderboard())

6. 行为准则提炼

6.1 检索策略选择准则

准则1：评估先行，优化有据 - 在优化RAG系统前，先使用RAG Triad建立评估基线 - 量化Context Relevance、Groundedness、Answer Relevance三个指标 - 只有指标显示问题后，才针对性优化

准则2：场景驱动技术选型 - 细粒度精准匹配场景 → 使用Sentence-Window Retrieval - 长文档层级理解场景 → 使用Auto-Merging Retrieval - 混合场景 → 可组合使用多种检索策略

6.2 Chunking策略准则

准则3：解耦检索粒度与生成粒度 - 检索时使用更小的chunk以提高精准度 - 生成时使用更大的上下文以提高完整性 - Sentence-Window通过metadata.window实现解耦

准则4：保留文档层级信息 - 使用HierarchicalNodeParser建立父子关系 - 为每个chunk注入文档结构元数据（标题、层级、页码） - 利用prev_node和next_node关系获取前后文

6.3 评估与迭代准则

准则5：建立持续评估机制 - 开发阶段：每次提交都运行评估 - 生产阶段：抽样10%请求进行评估 - 使用TruLens Dashboard追踪指标趋势

准则6：阈值驱动的优化决策 - Context Relevance < 0.7 → 优化检索策略 - Groundedness < 0.8 → 优化Prompt或增加上下文 - Answer Relevance < 0.75 → 优化查询理解或答案生成

6.4 性能与质量平衡准则

准则7：两阶段检索架构 - 第一阶段（候选选择）：使用Hybrid Search（RRF融合）召回Top-100 - 第二阶段（精准排序）：使用Cross-Encoder对Top-10重排序 - 平衡召回率与精确率

准则8：缓存与评估的权衡 - 高频查询 → 启用语义缓存降低延迟 - 低频但关键查询 → 每次都完整评估 - 建立缓存命中率与评估覆盖率的监控

7. 看宝AI记忆系统设计方案

7.1 需求分析

看宝AI作为一个私人AI助手，需要： 1. 短期记忆：当前会话上下文 2. 长期记忆：跨会话积累的知识 3. 事实记忆：用户的偏好、习惯、经历 4. 技能记忆：学习到的SOP和方法论

7.2 RAG驱动的记忆系统架构

┌─────────────────────────────────────────────────────────────────────┐
│                    看宝AI记忆系统架构                                  │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │                    记忆输入层                                 │   │
│  │  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐         │   │
│  │  │ 对话摘要 │  │ 文档解析 │  │ 经验提取 │  │ 反馈收集 │         │   │
│  │  └────┬────┘  └────┬────┘  └────┬────┘  └────┬────┘         │   │
│  └───────┼────────────┼────────────┼────────────┼──────────────┘   │
│          │            │            │            │                     │
│          └────────────┴─────┬──────┴────────────┘                     │
│                             ▼                                          │
│  ┌─────────────────────────────────────────────────────────────┐     │
│  │                    记忆索引层                                 │     │
│  │  ┌─────────────────────────────────────────────────────┐   │     │
│  │  │              Hierarchical Memory Index               │   │     │
│  │  │  ┌─────────┐  ┌─────────┐  ┌─────────┐  ┌─────────┐   │   │     │
│  │  │  │事实记忆 │  │ 偏好记忆 │  │ 技能记忆 │  │ 经验记忆 │   │   │     │
│  │  │  │(原子级) │  │(实体级)  │  │(概念级) │  │(叙事级)  │   │   │     │
│  │  │  └────┬────┘  └────┬────┘  └────┬────┘  └────┬────┘   │   │     │
│  │  │       └────────────┴────────────┴────────────┘         │   │     │
│  │  │                         │                               │   │     │
│  │  │              Sentence-Window + Auto-Merging             │   │     │
│  │  └─────────────────────────────────────────────────────────┘   │     │
│  └────────────────────────────┬───────────────────────────────────┘     │
│                               ▼                                          │
│  ┌─────────────────────────────────────────────────────────────┐     │
│  │                    记忆检索层                                 │     │
│  │  ┌─────────────────────────────────────────────────────┐   │     │
│  │  │              Hybrid Search + Reranking              │   │     │
│  │  │  - Dense Retrieval (语义相似)                        │   │     │
│  │  │  - Sparse Retrieval (关键词匹配)                      │   │     │
│  │  │  - Cross-Encoder Reranking                          │   │     │
│  │  └─────────────────────────────────────────────────────┘   │     │
│  └────────────────────────────┬───────────────────────────────────┘     │
│                               ▼                                          │
│  ┌─────────────────────────────────────────────────────────────┐     │
│  │                    记忆检索层                                 │     │
│  │  ┌─────────────────────────────────────────────────────┐   │     │
│  │  │              TruLens Evaluation                     │   │     │
│  │  │  - Context Relevance: 记忆是否相关                  │   │     │
│  │  │  - Groundedness: 记忆是否准确                       │   │     │
│  │  │  - Answer Relevance: 回答是否有用                   │   │     │
│  │  └─────────────────────────────────────────────────────┘   │     │
│  └─────────────────────────────────────────────────────────────┘     │
│                                                                      │
└─────────────────────────────────────────────────────────────────────┘

7.3 记忆类型与检索策略映射

记忆类型	描述	检索粒度	Chunk策略	示例
事实记忆	用户明确告诉的事实	原子级（单句）	Sentence-Window	"我叫张三"
偏好记忆	用户的行为偏好	实体级	Auto-Merging	喜欢简洁回答
技能记忆	用户关注的方法论	概念级	层级+元数据	学习SOP
经验记忆	用户过往经历	叙事级	大Chunk+结构化	项目经历

7.4 关键实现代码

# 看宝AI记忆系统核心实现

from llama_index.core import VectorStoreIndex, StorageContext
from llama_index.core.node_parser import HierarchicalNodeParser, SentenceWindowNodeParser
from llama_index.core.retrievers import AutoMergingRetriever
from llama_index.core.postprocessor import MetadataReplacementPostProcessor
from llama_index.core.schema import Document
from typing import List, Dict, Any
import json
from datetime import datetime

class KanbaoMemorySystem:
    """看宝AI记忆系统"""

    def __init__(self):
        # 记忆存储
        self.fact_index = None      # 事实记忆索引
        self.preference_index = None # 偏好记忆索引
        self.skill_index = None     # 技能记忆索引
        self.experience_index = None # 经验记忆索引

        # 元数据存储
        self.metadata_store = {}

    def add_memory(self, memory_type: str, content: str, metadata: Dict):
        """添加记忆"""
        doc = Document(
            text=content,
            metadata={
                **metadata,
                "memory_type": memory_type,
                "created_at": datetime.now().isoformat()
            }
        )

        # 根据记忆类型选择索引策略
        if memory_type == "fact":
            self._add_sentence_window_memory(doc)
        else:
            self._add_hierarchical_memory(doc)

    def _add_sentence_window_memory(self, doc: Document):
        """句子窗口检索 - 适合事实记忆"""
        node_parser = SentenceWindowNodeParser.from_defaults(
            window_size=2
        )
        nodes = node_parser.get_nodes_from_documents([doc])
        self.fact_index = VectorStoreIndex(nodes)

    def _add_hierarchical_memory(self, doc: Document):
        """层级检索 - 适合偏好、技能、经验记忆"""
        node_parser = HierarchicalNodeParser.from_defaults(
            chunk_sizes=[2048, 512, 128]
        )
        nodes = node_parser.get_nodes_from_documents([doc])
        leaf_nodes = get_leaf_nodes(nodes)

        storage_context = StorageContext.from_defaults(
            docstore=SimpleDocumentStore()
        )
        storage_context.docstore.add_documents(nodes)

        if "preference" in doc.metadata.get("memory_type", ""):
            self.preference_index = VectorStoreIndex(leaf_nodes, storage_context=storage_context)
        elif "skill" in doc.metadata.get("memory_type", ""):
            self.skill_index = VectorStoreIndex(leaf_nodes, storage_context=storage_context)
        else:
            self.experience_index = VectorStoreIndex(leaf_nodes, storage_context=storage_context)

    def retrieve(self, query: str, memory_types: List[str] = None) -> List[Dict]:
        """检索记忆"""
        results = []

        if memory_types is None:
            memory_types = ["fact", "preference", "skill", "experience"]

        for mem_type in memory_types:
            index = self._get_index(mem_type)
            if index:
                retriever = self._get_advanced_retriever(index)
                nodes = retriever.retrieve(query)
                results.extend([{
                    "type": mem_type,
                    "content": node.text,
                    "score": node.score,
                    "metadata": node.metadata
                } for node in nodes])

        # 按相关性排序
        results.sort(key=lambda x: x["score"], reverse=True)
        return results

    def _get_advanced_retriever(self, index):
        """获取高级检索器"""
        base_retriever = index.as_retriever(similarity_top_k=6)
        storage_context = StorageContext.from_defaults()
        return AutoMergingRetriever(
            base_retriever,
            storage_context,
            simple_ratio_thresh=0.5
        )

7.5 评估集成

from trulens import Tru
from trulens.feedback import Feedback, Groundedness, AnswerRelevance, ContextRelevance

class KanbaoMemoryEvaluator:
    """看宝AI记忆评估器"""

    def __init__(self, memory_system: KanbaoMemorySystem):
        self.tru = Tru()
        self.memory_system = memory_system

        # 初始化评估函数
        self._setup_feedback_functions()

    def _setup_feedback_functions(self):
        """设置评估函数"""
        self.f_context_relevance = Feedback(
            ContextRelevance().Relevance
        ).on_input()

        self.f_groundedness = Feedback(
            Groundedness().groundedness_measure
        ).on_output()

        self.f_answer_relevance = Feedback(
            AnswerRelevance().Relevance
        ).on_input_output()

    def evaluate_retrieval(self, query: str) -> Dict[str, float]:
        """评估检索质量"""
        results = self.memory_system.retrieve(query)

        if not results:
            return {"context_relevance": 0, "groundedness": 0, "answer_relevance": 0}

        # 聚合检索结果为上下文
        context = "\n".join([r["content"] for r in results[:3]])

        # 模拟评估（实际应调用LLM评估）
        return {
            "context_relevance": sum(r["score"] for r in results[:3]) / 3,
            "groundedness": 0.85,  # 基于上下文的假设值
            "answer_relevance": 0.80
        }

    def get_leaderboard(self) -> pd.DataFrame:
        """获取评估仪表板"""
        return self.tru.get_leaderboard()

7.6 实施路线图

阶段1：基础RAG记忆系统（1-2周）
├── 实现基础Sentence-Window检索
├── 建立记忆存储结构
└── 手工评估验证

阶段2：高级检索优化（2-3周）
├── 实现Auto-Merging层级检索
├── 集成Hybrid Search
└── Cross-Encoder重排序

阶段3：评估体系建设（1-2周）
├── TruLens评估框架集成
├── 自动化评估流程
└── Dashboard监控

阶段4：生产优化（持续）
├── 缓存策略
├── 性能调优
└── 用户反馈循环

8. 参考资源

8.1 课程资源

课程链接：https://www.deeplearning.ai/short-courses/building-evaluating-advanced-rag/
LlamaIndex文档：https://docs.llamaindex.ai/
TruLens文档：https://www.trulens.org/

8.2 GitHub仓库

课程Notebook：https://github.com/monoboard1/Building-and-Evaluating-Advanced-RAG-Applications

8.3 关键论文

Reciprocal Rank Fusion：Gordon V. Cormack et al., SIGIR 2009
RAG-Fusion：Zackary Rackauckas, 2024
GraphRAG：Microsoft Research, 2024

9. 学习心得

9.1 核心收获

评估驱动开发：RAG Triad提供了一套可量化的评估体系，让优化有据可依
粒度解耦思想：Sentence-Window的核心洞见是"检索粒度"与"生成粒度"可以不同
层级索引价值：Auto-Merging利用文档固有结构，避免强制切分破坏语义

9.2 实践建议

起步用Sentence-Window：实现简单，效果显著
评估先行：建立基线后再优化，避免过早优化
缓存关键：高频查询使用语义缓存降低延迟
监控趋势：TruLens Dashboard追踪指标变化

9.3 看宝AI应用

将RAG技术应用于看宝AI记忆系统： - 事实记忆：Sentence-Window精准匹配 - 技能记忆：Auto-Merging层级理解 - 持续评估：TruLens保证记忆质量

学习日期：2026-04-11
课程完成度：100%
笔记整理：AI Agent

Building and Evaluating Advanced RAG 学习笔记