Reflection，提升Agent的质量和成功率！

导语

反思（Reflection）是一种提示策略，用于提高 agent 和类 AI 系统的质量及成功率。这篇文章概述了如何使用 LangGraph 构建 3 种反思方法，包括 Reflexion 和 Language Agent Tree Search（LATS）。

提示：
LATS（Language Agent Tree Search）是一种新的框架，它将 LLM 的能力整合到决策制定和推理中。LATS 的主要思想是利用蒙特卡洛树搜索（Monte Carlo Tree Search，MCTS）来指导 LLM 进行决策制定和推理。通过这种方式，LATS 将 LLM 的强大语言理解和推理能力与 MCTS 的搜索和优化能力相结合，实现了更灵活、更适应环境的决策制定和推理。相比简单的 LLM prompting 方法，LATS 可以更好地处理复杂决策问题，同时也可以通过环境反馈来增强 LLM 的推理能力。

概述

代码实现指引

• Simple Reflection🔗：https://github.com/langchain-ai/langgraph/blob/main/examples/reflection/reflection.ipynb?ref=blog.langchain.dev

• Reflexion：https🔗://github.com/langchain-ai/langgraph/blob/main/examples/reflexion/reflexion.ipynb?ref=blog.langchain.dev

• Language Agents Tree Search🔗：https://github.com/langchain-ai/langgraph/blob/main/examples/lats/lats.ipynb?ref=blog.langchain.dev

Reflection 归根到底还是一种提示词策略，用于提高 agent 和类 AI 应用的质量和成功率。它促使 LLM 对其已执行过的结果进行反思和批评，有时还包括额外的外部信息，如工具观察结果等。

假设有两个系统：系统 1 和系统 2，系统 1 是基于反应或者本能的，而系统 2 则更有条理和反思性。如果应用得当，反思就可以帮助 LLM 系统摆脱纯粹的系统 1 的“思维”模式，更接近系统 2 的行为。

反思会消耗时间的消耗！这篇文章中的所有方法都权衡了一些额外的计算，以求活的更好的输出质量。虽然这可能不适用于低延迟应用程序，但对于响应质量比速度更重要的知识密集型任务来说，这是值得的。

Basic Reflection

示例代码 🔗：https://github.com/langchain-ai/langgraph/blob/main/examples/reflection/reflection.ipynb?ref=blog.langchain.dev

这个简单的示例由两个 LLM 调用组成：生成器和反思器。生成器会直接响应用户的请求。反思器被提示词设计为扮演教师的角色，并为初始反应提供建设性的评论。

最中结果会在循环执行固定次数之后返回。

可以在下面定义 LangGraph 中的循环：

from langgraph.graph import MessageGraph

builder = MessageGraph()
builder.add_node("generate", generation_node)
builder.add_node("reflect", reflection_node)
builder.set_entry_point("generate")


def should_continue(state: List[BaseMessage]):
    if len(state) > 6:
        return END
    return "reflect"


builder.add_conditional_edges("generate", should_continue)
builder.add_edge("reflect", "generate")
graph = builder.compile()

MessageGraph 表示一个有状态的图，其中的“状态”只是一个消息列表。每次调用生成器（generate）或反思器（reflect）节点时，它都会在状态的末尾附加一条消息。最终结果从生成器节点返回。

这种简单类型的反思可以通过一些方式提高性能，方法是让 LLM 多次尝试改进其输出，并让反思节点在评论输出时采用不同的角色。

但是，由于反思过程没有任何外部干预，因此最终结果可能也不会明显优于原始结果。

Reflexion

示例代码 🔗：https://github.com/langchain-ai/langgraph/blob/main/examples/reflexion/reflexion.ipynb?ref=blog.langchain.dev

由 Shinn 等人设计的 reflection 是一种通过口头反馈和自我反思来学习的架构。在反思中，actor agent 明确地评论每个响应，并以外部数据为基础进行评论，它强制生成引用，并明确地列举生成的响应中多余和缺失的方面。这使得反思的内容更具建设性，并更好地引导生成器响应反馈。

在示例中，执行固定次数的步骤之后将会停止。当然，这个操作也可以交给 reflection LLM 的调用。

agent 循环的概览如图：

对于每个步骤，Responder 的任务是生成响应，以及以搜索查询的形式进行的其他操作。然后，会提示 Revisor 对当前状态进行反思。在 LangGraph 中，逻辑可以定义如下:

from langgraph.graph import END, MessageGraph

MAX_ITERATIONS = 5
builder = MessageGraph()
builder.add_node("draft", first_responder.respond)
builder.add_node("execute_tools", execute_tools)
builder.add_node("revise", revisor.respond)
# draft -> execute_tools
builder.add_edge("draft", "execute_tools")
# execute_tools -> revise
builder.add_edge("execute_tools", "revise")

# Define looping logic:
def event_loop(state: List[BaseMessage]) -> str:
    # in our case, we'll just stop after N plans
    num_iterations = _get_num_iterations(state)
    if num_iterations > MAX_ITERATIONS:
        return END
    return "execute_tools"


# revise -> execute_tools OR end
builder.add_conditional_edges("revise", event_loop)
builder.set_entry_point("draft")
graph = builder.compile()

该 agent 可以有效地使用显式反思和基于 web 的引用来提高最终响应的质量。然而，它只追求一个固定的轨迹，所以如果它犯了一个错误，这个错误可能会影响后续的决策。

Language Agent Tree Search

示例代码 🔗：https://github.com/langchain-ai/langgraph/blob/main/examples/lats/lats.ipynb?ref=blog.langchain.dev

Language Agent Tree Search(LATS)是一种通用的 LLM 代理搜索算法，它结合了反思/评估和搜索(特别是蒙特卡罗树搜索)，与 ReACT、reflex 甚至思想树等类似技术相比，可以实现更好的整体任务性能。它采用标准的强化学习(RL)任务框架，将 RL agents、值函数和优化器全部替换为对 LLM 的调用。这是为了帮助代理适应和解决复杂任务的问题，避免陷入重复循环。

过程概述如图：

搜索有四个主要步骤：

1. Select
   选择：根据下面第 2 步中的总奖励选择最佳的后续行动。返回响应（如果找到解决方案或达到最大搜索深度）或继续搜索。

2. Expand and simulate
   扩展和模拟：生成N个潜在的操作步骤，然后并行执行他们。

3. Reflect + evaluate
   反思 & 评估：观察这些执行的输出结果，并根据反思（可能还有外部反馈）对决策进行评分。

4. Backpropagate
   反向传播：根据结果更新根轨迹的分数。

如果agent有一个紧密的反馈回路(通过高质量的环境奖励或可靠的反思分数)，搜索就能够准确地区分不同的行动轨迹，并选择最佳路径。最后的轨迹可以保存到外部存储器中(或用于模型微调)，以便将来改进模型。

“selection”步骤中选择具有最高置信上限(UCT)的节点，这正好平衡了预期奖励(第一项)和探索新路径的激励(第二项)。

在下面的LangGraph实现中，将生成+反思步骤分别放在单独节点中，并检查每个循环的树状态，以查看任务是否已解决。图形定义大致如下:

from langgraph.graph import END, StateGraph

class Node:
    def __init__(
        self,
        messages: List[BaseMessage],
        reflection: Reflection,
        parent: Optional[Node] = None,
    ):
        self.messages = messages
        self.parent = parent
        self.children = []
        self.value = 0
        self.visits = 0
    # Additional methods are defined here. Check the code for more!

class TreeState(TypedDict):
    # The full tree
    root: Node
    # The original input
    input: str

def should_loop(state: TreeState):
    """Determine whether to continue the tree search."""
    root = state["root"]
    if root.is_solved:
        return END
    if root.height > 5:
        return END
    return "expand"


builder = StateGraph(TreeState)
builder.add_node("start", generate_initial_response)
builder.add_node("expand", expand)
builder.set_entry_point("start")


builder.add_conditional_edges(
    "start",
    # Either expand/rollout or finish
    should_loop,
)
builder.add_conditional_edges(
    "expand",
    # Either continue to rollout or finish
    should_loop,
)

graph = builder.compile()

一旦你创建了基本的大纲，扩展到其他任务就很容易了!例如，这种技术将非常适合代码生成任务，其中代理可以编写显式的单元测试并根据测试质量对轨迹进行评分。

LATS 统一了其他 agent 架构的推理、规划和反思组件，例如 Reflexion、Tree of Thoughts 和 plan-and-execute agents。LATS还从反向传播的反思和基于环境的反馈中改进了搜索过程。通用算法虽然对奖励分数比较敏感，但可以灵活地应用于各种任务。

结论

所有的代码示例，都可以从下面的地址查看和阅读：
https://github.com/langchain-ai/langgraph/tree/main?ref=blog.langchain.dev

上述所有技术方案都利用额外的LLM推理来提高生成更高质量输出的可能性，或者对更复杂的推理任务做出正确响应的可能性。虽然这需要额外的时间，但当输出质量比响应时间更重要时，如果您将轨迹保存到内存中(或作为微调数据)，则可以更新模型以避免将来重复错误。

本文由mdnice多平台发布