GRASP：基于强化学习的智能检索策略，解决RAG系统检索粒度匹配难题

1. 项目概述：当RAG遇上“思考”，GRASP如何重塑检索策略？

最近在折腾Agentic RAG（智能体驱动的检索增强生成）项目时，我遇到了一个挺典型的问题：传统的RAG系统，无论是用简单的相似度搜索，还是加上一些重排序（Re-ranking）技巧，本质上都是一次性、静态的“检索-生成”过程。模型拿到检索结果后，直接“吞下去”就生成答案，中间缺乏一个关键的“咀嚼”和“思考”环节。尤其是在处理复杂、多步骤的查询时，比如“请对比分析A公司和B公司在过去五年内的市场战略演变及其对行业的影响”，一次性返回的文档片段往往要么太粗（涵盖面广但细节缺失），要么太细（陷入某个具体细节而丢失全局），很难一步到位地满足生成高质量答案所需的全部信息粒度。

这其实就是 检索粒度（Granularity） 的匹配问题。而“GRASP: GRanularity-Aware Search Policy for Agentic RAG”这个项目，正是为了解决这个问题而生。它不是一个简单的工具包，而是一套 基于强化学习（Reinforcement Learning）训练出来的、具备动态决策能力的搜索策略 。你可以把它想象成给RAG系统装上了一个“智能调度员”。这个调度员不直接干活，它的核心任务是：面对用户的一个复杂问题，决定应该怎么去“翻阅”背后的知识库——是先快速浏览目录（粗粒度检索）锁定大致范围，再精读相关章节（细粒度检索）获取细节？还是直接深入某个技术白皮书（细粒度）获取核心参数？这个决策过程，就是GRASP要学习和优化的策略。

它的价值在于，将RAG从一个被动的、基于固定规则的信息提取工具，升级为一个主动的、具备多步推理能力的“信息探索智能体”。这对于构建企业级知识问答、复杂研究助手、多轮对话系统等场景至关重要。简单来说，GRASP试图教会RAG系统“如何更聪明地提问和查找”，而不是机械地匹配关键词。

2. GRASP核心设计思路：把检索过程建模为序列决策

要理解GRASP，首先得跳出“一次检索定终身”的思维定式。GRASP的核心思想是： 将一个复杂的问答任务，分解为一系列有序的检索动作（Action），每个动作都对应着在特定粒度上对知识库的一次查询。

2.1 问题形式化：马尔可夫决策过程（MDP）

GRASP将整个Agentic RAG的交互过程，形式化为一个标准的 马尔可夫决策过程（Markov Decision Process, MDP） 。这是强化学习的经典框架。我们来拆解一下其中的几个关键要素：

• 状态（State, S_t） ：在时间步t，智能体（即GRASP策略）所感知到的所有信息。这通常包括：

  • 原始用户查询（Query） ：需要回答的复杂问题。
  • 对话历史（History） ：在多轮对话中，之前的问题和答案。
  • 已检索到的上下文（Retrieved Context） ：到目前为止，通过之前所有检索动作收集到的文档片段集合。
  • 当前推理的中间结果（Intermediate Reasoning） ：智能体内部可能产生的一些思考链（Chain-of-Thought）或暂定结论。 这个状态S_t，综合反映了任务当前的进展和所需信息的满足程度。

• 动作（Action, A_t） ：智能体在状态S_t下可以采取的操作。在GRASP中，动作空间被精心设计为 与检索粒度相关的搜索指令 。一个动作可能包含两部分：

  1. 粒度选择 ：决定下一次检索的粗细程度。例如，可以定义几个级别： “章节标题”级（最粗） 、 “段落”级（中等） 、 “句子”级（最细） ，甚至是 “跨文档摘要”级 。
  2. 查询构造 ：基于当前状态，生成一个具体的搜索查询词（Search Query）。这个查询词不是原封不动的用户问题，而是策略网络根据已有信息“思考”后生成的、更精准的提问。例如，面对“分析市场战略”，在已经检索到公司概览后，下一个动作可能是生成查询“A公司 2022年 产品发布会 具体举措”，并指定在“段落”粒度进行搜索。

• 奖励（Reward, R_t） ：智能体执行动作A_t，从状态S_t转移到新状态S_{t+1}后，环境给出的反馈信号。这是驱动策略学习的关键。GRASP的奖励函数设计非常巧妙，通常结合：

  • 最终答案质量奖励 ：任务结束时，根据生成答案的准确性、完整性、相关性（可通过与标准答案对比或LLM自我评估得到）给出一个大奖励。
  • 中间过程奖励 ：为了鼓励高效探索，可能会设置一些中间奖励。例如，当一次检索动作新引入的文档片段与当前上下文有高信息增益（Information Gain）但冗余度低时，给予正奖励；如果检索结果完全无关或高度重复，则给予负奖励（惩罚）。这引导策略学习如何用最少的、最精准的检索步骤覆盖所需信息。

• 策略（Policy, π） ：这就是GRASP要学习的核心——一个参数化的函数（通常是一个神经网络），它接收当前状态S_t，并输出一个在动作空间A上的概率分布π(A_t | S_t)。策略决定了在何种状态下，应以多大可能性采取哪个检索动作。

2.2 策略网络架构：Actor部分的设计

GRASP通常采用Actor-Critic这类策略梯度算法。其中， Actor网络 就是策略π的具体实现。它的设计要点如下：

1. 状态编码器 ：首先，需要将复杂的文本状态（查询、历史、上下文等）编码成固定维度的向量表示。这里会用到预训练的语言模型（如BERT、RoBERTa或一个小型的LLM）作为编码器，将文本序列转化为富含语义的嵌入（Embedding）。
2. 历史集成模块 ：由于状态包含多轮交互和多次检索的结果，需要一个模块（如循环神经网络RNN、Transformer或简单的注意力池化）来融合这些时序信息，形成一个统一的“状态表征”。
3. 策略头（Policy Head） ：基于统一的状态表征，通过一个全连接网络，输出每个可能动作（粒度-查询对）的得分或概率。这里，“查询构造”部分比较有挑战性，一种常见做法是让策略网络生成一个“查询生成提示”，再通过一个轻量级的文本生成模块（或直接从词表采样）产生具体的查询文本。

注意 ：动作空间如果是离散的（如预定义了几种粒度和查询模板），那么策略头就是一个分类网络。如果查询文本是生成的，则可能涉及序列生成，复杂度会更高。

2.3 为什么是强化学习，而不是监督学习？

你可能会问，既然我们有用户问题和标准答案，为什么不直接用监督学习，让模型学习“给定问题，直接输出最佳检索序列”呢？原因在于 搜索路径的复杂性和稀疏奖励 。

1. 搜索路径组合爆炸 ：对于一个复杂问题，可能存在无数种不同的检索序列都能最终导向正确答案。监督学习需要大量“问题-最优检索序列”的标注数据，这几乎无法获得。
2. 奖励稀疏且滞后 ：只有生成最终答案后，才能知道检索序列的好坏（答案质量）。在漫长的多步检索过程中，缺乏即时的、细粒度的反馈。强化学习，特别是结合了中间奖励设计的RL，非常适合处理这种 延迟奖励 和 探索-利用 的权衡问题。它允许智能体通过试错，自己去发现那些能高效积累奖励（即高效获取信息）的动作序列。

3. GRASP实战：构建与训练一个粒度感知的搜索智能体

理论说得再多，不如动手搭一个。下面我将以一个简化版的企业知识库问答场景为例，拆解GRASP的实现关键步骤。假设我们的知识库是关于某科技公司的，包含产品手册、技术白皮书、市场报告和会议纪要等文档，并已做好向量化索引。

3.1 环境搭建：定义状态、动作与奖励

首先，我们需要模拟一个RAG环境，供GRASP智能体进行交互和学习。

import numpy as np
from typing import List, Dict, Tuple, Any
from some_vector_db import VectorStore # 假设的向量数据库客户端
from some_llm import LLM # 假设的大语言模型客户端

class GraspRAGEnvironment:
    def __init__(self, vector_db: VectorStore, llm: LLM, max_steps: int = 5):
        self.vector_db = vector_db
        self.llm = llm
        self.max_steps = max_steps
        self.granularity_levels = ['section', 'paragraph', 'sentence'] # 定义三个粒度
        self.reset()

    def reset(self, query: str):
        """重置环境，开始一个新的问答任务"""
        self.query = query
        self.retrieved_context = [] # 已检索的上下文列表
        self.current_step = 0
        self.done = False
        # 初始状态：仅包含用户查询
        initial_state = self._get_state_representation()
        return initial_state

    def _get_state_representation(self) -> Dict[str, Any]:
        """将当前环境信息编码为状态表征（此处为简化示意）"""
        # 在实际实现中，这里会调用一个编码器模型（如BERT）来生成嵌入
        # 简化为返回文本和元信息的拼接
        state = {
            'original_query': self.query,
            'retrieved_texts': self.retrieved_context,
            'retrieved_metadata': [ctx['metadata'] for ctx in self.retrieved_context],
            'step': self.current_step
        }
        return state

    def step(self, action: Dict) -> Tuple[Dict, float, bool, Dict]:
        """
        执行一个动作。
        action: 包含 'granularity' 和 'generated_query' 的字典。
        返回: (next_state, reward, done, info)
        """
        if self.done or self.current_step >= self.max_steps:
            return self._get_state_representation(), 0.0, True, {'msg': 'Episode terminated'}

        # 1. 执行检索
        granularity = action['granularity']
        search_query = action['generated_query']
        # 根据粒度，可能需要在向量数据库中使用不同的索引或过滤条件
        search_results = self.vector_db.search(
            query=search_query,
            filter_by_granularity=granularity, # 假设向量库支持按元数据过滤粒度
            top_k=3
        )

        # 2. 更新检索上下文（简单的去重和截断逻辑）
        for res in search_results:
            if res['text'] not in [ctx['text'] for ctx in self.retrieved_context]:
                self.retrieved_context.append({
                    'text': res['text'],
                    'metadata': res['metadata'],
                    'step': self.current_step
                })
        # 保持上下文不超过一定长度
        if len(self.retrieved_context) > 10:
            self.retrieved_context = self.retrieved_context[-10:]

        # 3. 计算奖励（简化版）
        reward = self._compute_reward(search_results, action)

        # 4. 检查是否应提前结束或继续
        self.current_step += 1
        if self.current_step >= self.max_steps:
            self.done = True
            # 最终答案奖励在最终步骤计算
            final_answer_reward = self._get_final_answer_quality()
            reward += final_answer_reward
        else:
            # 检查当前上下文是否已足够回答问题（启发式判断）
            if self._is_context_sufficient():
                self.done = True
                reward += 1.0 # 给予提前正确完成的奖励

        next_state = self._get_state_representation()
        info = {'retrieved_count': len(search_results), 'step': self.current_step}
        return next_state, reward, self.done, info

    def _compute_reward(self, results: List, action: Dict) -> float:
        """计算即时奖励。这是一个需要精心设计的核心函数。"""
        reward = 0.0
        # 示例奖励设计：
        # 1. 相关性奖励：检索结果与当前查询的语义相关性（可用检索得分近似）
        avg_similarity = np.mean([r['score'] for r in results]) if results else 0
        reward += avg_similarity * 0.1

        # 2. 新颖性奖励：鼓励检索到新信息（与已有上下文对比）
        # 此处简化，实际需计算文本相似度
        if results and not self.retrieved_context:
            reward += 0.2 # 第一次检索到任何信息都鼓励

        # 3. 粒度适配奖励：根据当前任务阶段，鼓励合适的粒度
        # 例如，初期鼓励粗粒度，后期鼓励细粒度（需根据状态判断阶段）
        # 此处省略具体逻辑

        # 4. 惩罚冗余步骤
        if not results: # 检索结果为空
            reward -= 0.1
        return reward

    def _is_context_sufficient(self) -> bool:
        """启发式判断当前上下文是否足够生成答案（简化）"""
        # 实际中，可以用一个小的判断模型或规则
        total_text_len = sum(len(ctx['text']) for ctx in self.retrieved_context)
        return total_text_len > 500 # 假设总长度大于500字符认为可能足够

    def _get_final_answer_quality(self) -> float:
        """在任务结束时，调用LLM生成答案并评估质量，返回最终奖励。"""
        combined_context = "\n".join([ctx['text'] for ctx in self.retrieved_context])
        prompt = f"基于以下信息：\n{combined_context}\n\n请回答问题：{self.query}"
        final_answer = self.llm.generate(prompt)

        # 评估答案质量（简化：使用另一个LLM进行自我评估或与参考答案对比）
        # 这里返回一个模拟的奖励值
        # 真实场景需要设计稳定的评估器（LLM-as-a-Judge或人工标注）
        return np.random.uniform(0.5, 1.5) # 模拟奖励

3.2 智能体构建：实现Actor-Critic算法

接下来，我们实现一个简化版的Actor-Critic智能体。这里使用PyTorch框架示意。

import torch
import torch.nn as nn
import torch.optim as optim
from torch.distributions import Categorical

class StateEncoder(nn.Module):
    """编码文本状态为向量"""
    def __init__(self, input_dim, hidden_dim):
        super().__init__()
        # 实际中，这里可能是一个预训练模型（如BERT）的封装
        self.fc1 = nn.Linear(input_dim, hidden_dim)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_dim, hidden_dim)

    def forward(self, state_features):
        # state_features: 已经过预处理的数值化状态特征
        x = self.fc1(state_features)
        x = self.relu(x)
        x = self.fc2(x)
        return x

class ActorNetwork(nn.Module):
    """策略网络（Actor）"""
    def __init__(self, state_dim, action_dim):
        super().__init__()
        self.encoder = StateEncoder(state_dim, 128)
        # 假设动作空间是离散的：粒度选择（3种） * 查询模板选择（5种） = 15个动作
        self.policy_head = nn.Linear(128, action_dim)

    def forward(self, state):
        state_rep = self.encoder(state)
        logits = self.policy_head(state_rep)
        return logits

    def get_action(self, state):
        logits = self.forward(state)
        probs = torch.softmax(logits, dim=-1)
        dist = Categorical(probs)
        action_idx = dist.sample()
        log_prob = dist.log_prob(action_idx)
        return action_idx.item(), log_prob

class CriticNetwork(nn.Module):
    """价值网络（Critic）"""
    def __init__(self, state_dim):
        super().__init__()
        self.encoder = StateEncoder(state_dim, 128)
        self.value_head = nn.Linear(128, 1)

    def forward(self, state):
        state_rep = self.encoder(state)
        value = self.value_head(state_rep)
        return value

class GraspAgent:
    def __init__(self, state_dim, action_dim, lr=1e-3, gamma=0.99):
        self.actor = ActorNetwork(state_dim, action_dim)
        self.critic = CriticNetwork(state_dim)
        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=lr)
        self.critic_optimizer = optim.Adam(self.critic.parameters(), lr=lr)
        self.gamma = gamma # 折扣因子
        self.saved_log_probs = []
        self.rewards = []

    def select_action(self, state):
        # 将状态转换为Tensor
        state_tensor = torch.FloatTensor(state).unsqueeze(0)
        action_idx, log_prob = self.actor.get_action(state_tensor)
        self.saved_log_probs.append(log_prob)
        # 将动作索引解码为具体的粒度和查询（需要有一个映射表）
        return self._decode_action(action_idx)

    def _decode_action(self, action_idx):
        # 简化映射：假设前3个动作对应'section'粒度，中间5个对应'paragraph'，最后7个对应'sentence'
        # 并为每个组合预定义了一个查询模板（如“关于{query}的概述”）
        granularity_list = ['section']*3 + ['paragraph']*5 + ['sentence']*7
        query_templates = [f"概述：{{query}}", f"{{query}} 的详细内容", ...] # 共15个模板
        granularity = granularity_list[action_idx]
        # 在实际中，查询模板需要与当前状态（如已有上下文）结合，动态填充生成最终查询字符串
        # 这里极度简化，仅返回模板索引
        return {'granularity': granularity, 'template_id': action_idx}

    def update_policy(self):
        """一个episode结束后，更新策略"""
        R = 0
        returns = []
        # 计算折扣回报
        for r in self.rewards[::-1]: # 从后往前
            R = r + self.gamma * R
            returns.insert(0, R)
        returns = torch.FloatTensor(returns)

        # 归一化回报，有助于训练稳定性
        returns = (returns - returns.mean()) / (returns.std() + 1e-8)

        policy_losses = []
        value_losses = []
        for log_prob, R in zip(self.saved_log_probs, returns):
            # 计算优势函数 A(s,a) = R - V(s)。这里用回报R近似替代Q值，减去基线V(s)
            # 注意：这里为了简化，没有重新计算每个状态下的V(s)。实际应使用Critic网络估计。
            advantage = R - self.critic(torch.FloatTensor(...)).item() # 需要状态输入，此处省略

            policy_losses.append(-log_prob * advantage) # 策略梯度损失
            # 价值网络损失（均方误差）
            value_losses.append(nn.functional.mse_loss(self.critic(torch.FloatTensor(...)), R.unsqueeze(0))) # 需要状态输入

        # 反向传播
        self.actor_optimizer.zero_grad()
        actor_loss = torch.stack(policy_losses).sum()
        actor_loss.backward()
        self.actor_optimizer.step()

        self.critic_optimizer.zero_grad()
        critic_loss = torch.stack(value_losses).sum()
        critic_loss.backward()
        self.critic_optimizer.step()

        # 清空缓存
        del self.rewards[:]
        del self.saved_log_probs[:]

3.3 训练循环与关键参数

将环境和智能体结合起来，进行训练。

def train_grasp(env, agent, num_episodes=1000):
    for episode in range(num_episodes):
        # 随机采样一个训练问题
        query = sample_training_query()
        state = env.reset(query)
        episode_reward = 0

        while not env.done:
            # 1. 智能体选择动作
            action = agent.select_action(state) # 注意：需要将state转换为特征向量
            # 2. 环境执行动作，反馈下一个状态和奖励
            next_state, reward, done, info = env.step(action)
            # 3. 存储奖励（用于后续更新）
            agent.rewards.append(reward)
            episode_reward += reward
            state = next_state

        # 一个episode结束，更新策略
        agent.update_policy()

        if episode % 100 == 0:
            print(f"Episode {episode}, Total Reward: {episode_reward:.2f}")
            # 可以在这里加入验证逻辑，在测试集上评估策略性能

关键参数与设计选择：

1. 状态特征化 ：这是最大的挑战之一。如何将文本、历史等非结构化信息转化为强化学习网络能处理的数值向量？通常需要先用一个预训练的语言模型（如Sentence-BERT）将所有文本组件编码成向量，然后通过池化、拼接或更复杂的序列模型（如LSTM/Transformer）进行融合。
2. 动作空间设计 ：
   • 离散 vs 连续 ：将粒度和查询模板组合成离散动作（如上述示例）易于实现，但灵活性受限。更高级的做法是将粒度视为离散参数，查询生成视为一个连续的文本生成问题，这需要结合策略梯度方法和序列生成模型（如使用GRU或Transformer解码器作为策略网络的一部分），复杂度剧增。
   • 查询生成 ：让策略网络直接生成查询文本非常困难。一个折中方案是学习一个“查询改写器”，它基于当前状态和选定的粒度，对原始用户查询或上一步的查询进行改写。例如，状态可能提示“需要更具体的财务数据”，那么改写器就会在原查询“公司业绩”基础上，增加“2023年 第四季度 净利润”等细节。
3. 奖励函数工程 ：这是GRASP成功与否的命门。糟糕的奖励函数会导致智能体学到奇怪的行为（例如，为了获取中间奖励而不断检索无关但高相似度的文档）。除了最终答案质量，好的中间奖励应鼓励：
   • 信息增益 ：新检索到的内容与已有上下文的信息差异度。
   • 覆盖度 ：检索结果对问题子主题的覆盖情况。
   • 效率 ：惩罚过多的检索步骤。 通常需要结合基于规则的奖励和基于学习到的奖励模型（Reward Model）来共同构建。

4. 实战中的挑战与优化策略

在实际构建GRASP系统时，你会遇到一系列教科书上不会写的坑。以下是我从几个实验项目中总结出的核心挑战和应对策略。

4.1 挑战一：样本效率低下与训练不稳定

强化学习，特别是策略梯度方法， notoriously（众所周知）存在样本效率低和训练不稳定的问题。在GRASP场景中，与环境（即RAG系统）交互一次成本很高（需要调用LLM生成答案进行评估），我们不可能进行数百万次的试错。

应对策略：

• 离线强化学习（Offline RL）与模仿学习（Imitation Learning）结合 ：
  1. 收集专家演示数据 ：首先，通过规则系统、启发式方法，或者干脆让人工专家演示，为一批复杂问题生成“相对合理”的检索序列。这构成了一个离线数据集。
  2. 行为克隆（Behavior Cloning） ：用这个数据集对策略网络（Actor）进行 监督预训练 ，让它初步学会模仿专家的搜索模式。这为策略提供了一个高质量的起点，避免了完全从随机探索开始。
  3. 离线RL微调 ：在预训练的基础上，使用离线RL算法（如Conservative Q-Learning, CQL）或离线策略的Actor-Critic算法（如AWAC），利用收集到的轨迹数据（状态、动作、奖励）进行进一步优化，让策略能够超越演示数据，发现更优的搜索策略。
• 使用世界模型（World Model）进行模拟 ：训练一个“环境模拟器”，它能够预测给定状态和动作后，会得到什么样的检索结果（文本片段）。这样，智能体的大部分试错可以在低成本的世界模型中进行，只有少数策略需要去真实环境验证。这大大提升了样本效率。

4.2 挑战二：奖励函数设计的主观性与偏差

奖励函数是人设计的，不可避免地带有主观性。如果奖励函数只强调答案的“流畅性”，智能体可能学会检索那些看起来相关、能拼凑出流畅答案，但事实错误的文档（即“幻觉”的另一种形式）。

应对策略：

• 多目标奖励 ：设计一个包含多个维度的奖励函数：
  • 事实一致性奖励 ：使用“事实核查”模型（如通过检索到的上下文来验证生成答案中的每个主张）来给予奖励或惩罚。
  • 引用质量奖励 ：鼓励答案中的声明都有明确的出处（来自检索到的上下文），并惩罚无引用的陈述。
  • 信息密度奖励 ：惩罚冗长的、信息量低的检索步骤。
• 基于LLM的奖励模型（LLM-as-a-Judge） ：不直接手工设计奖励函数，而是训练一个专门的奖励模型。这个模型以（状态，动作，下一状态）或（检索序列，最终答案）为输入，输出一个标量奖励。这个奖励模型的训练数据来自人类对轨迹质量的偏好排序（例如，给定两个不同的检索序列和最终答案，人类判断哪个更好）。这种方法能将人类对“好策略”的模糊判断，转化为可学习的奖励信号。

4.3 挑战三：动作空间巨大与探索困难

即使将粒度离散化为几种，查询文本的生成空间也是近乎无限的。智能体很容易陷入局部最优，比如永远只使用一种粒度和一种简单的查询改写方式。

应对策略：

• 分层策略（Hierarchical Policy） ：
  • 高层策略（Manager） ：负责制定抽象的“目标”，例如“下一步需要获取关于市场规模的细节信息”。这个目标是一个语义向量。
  • 底层策略（Worker） ：接收高层策略的目标向量和当前状态，负责执行具体的动作——即生成符合该目标的粒度选择和查询文本。这样，探索空间在高层的抽象目标上更小、更有意义。
• 课程学习（Curriculum Learning） ：不要一开始就让智能体处理最复杂的问题。先从简单的、单步检索就能解决的问题开始训练，逐步增加问题的复杂性和所需的检索步数。这有助于智能体稳步建立能力。
• 熵正则化（Entropy Regularization） ：在策略网络的损失函数中增加一项策略熵的奖励，鼓励策略保持一定的随机性，防止过早地收敛到单一动作模式。

4.4 挑战四：与现有RAG框架的集成

GRASP是一个“策略层”，它需要与底层的向量数据库、检索器、重排序器以及顶端的LLM生成器协同工作。

集成模式参考：

# 伪代码：GRASP与LangChain/LlamaIndex等框架的集成思路
class GraspEnhancedRAGChain:
    def __init__(self, grasp_agent, vector_store, llm, retriever, reranker=None):
        self.agent = grasp_agent
        self.vector_store = vector_store
        self.llm = llm
        self.retriever = retriever # 可以是多种检索器的组合
        self.reranker = reranker
        self.context = []

    def answer_complex_query(self, query: str, max_turns: int = 5):
        state = self._compose_initial_state(query)
        for step in range(max_turns):
            # 1. GRASP策略决定下一步怎么搜
            action = self.agent.select_action(state)
            granularity = action['granularity']
            sub_query = self._generate_sub_query(action, state)

            # 2. 执行检索（可能根据粒度选择不同的索引或检索器）
            if granularity == 'coarse':
                docs = self.retriever.retrieve_coarse(sub_query)
            elif granularity == 'fine':
                docs = self.retriever.retrieve_fine(sub_query)
            # ... 其他粒度

            # 3. （可选）重排序
            if self.reranker:
                docs = self.reranker.rerank(sub_query, docs)

            # 4. 更新状态（将新检索到的文档加入上下文）
            self._update_context(docs, step)
            new_state = self._compose_state(query, self.context, step)

            # 5. 判断是否满足停止条件（由策略或规则决定）
            if self._should_stop(new_state, action):
                break
            state = new_state

        # 6. 用最终收集的上下文生成答案
        final_context = self._format_context(self.context)
        answer = self.llm.generate(f"基于以下信息：\n{final_context}\n\n问题：{query}")
        return answer, self.context # 返回答案和检索轨迹，可用于分析和奖励计算

5. 效果评估与未来方向

如何判断你的GRASP系统真的比传统RAG更“聪明”？不能只看最终答案的准确率，因为那可能受LLM生成能力的影响很大。需要设计更细粒度的评估指标：

• 检索轨迹质量 ：
  • 步骤效率 ：平均每个问题需要多少检索步骤？
  • 累积信息增益 ：每个步骤新增的上下文带来了多少新信息？（可用文本相似度以外的度量，如基于嵌入的多样性指标）
  • 粒度适配度 ：检索动作的粒度分布是否符合人类直觉（如先粗后细）？
• 决策可解释性 ：能否解释为什么在某个步骤选择了特定的粒度和查询？这对于调试和信任至关重要。可以考虑为策略网络的决策添加注意力机制，可视化它关注了状态中的哪些部分。

GRASP代表了Agentic RAG向更高级认知能力迈进的重要一步。未来的方向可能包括：

• 多智能体协作 ：引入多个具有不同专长（如擅长检索宏观趋势、擅长查找具体数据）的搜索智能体，让它们协同工作来解决一个复杂问题。
• 与规划（Planning）结合 ：在检索之前，先让LLM对问题进行任务分解（Task Decomposition），生成一个初步的“信息获取计划”，然后GRASP策略负责执行并动态调整这个计划。
• 终身学习 ：让GRASP策略在部署后能持续从用户反馈中学习，适应新的知识领域和查询模式。

构建一个可用的GRASP系统需要投入大量的工程和调优工作，它目前更像是一个前沿的研究与工程结合点。但它的潜力是显而易见的——让RAG系统从“记忆库”变成真正的“思考伙伴”，能够主动、高效、精准地探索知识海洋，从而应对那些开放域、多跳、深度的复杂问答挑战。这或许是下一代企业级智能知识系统的核心组件之一。