AI Agents with LangChain & Autonomous Workflows · 课时

自我纠正与反思型智能体

学习构建能够批判性评估自身输出，并反复改进响应或行动的智能体

第 3 / 6 课11 个步骤

自我纠正与反思型智能体 是 CoddyKit 上的免费 AI Agents with LangChain & Autonomous Workflows 课时。这是第 3 节课，共 6 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 AI Agents with LangChain & Autonomous Workflows 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 AI Agents with LangChain & Autonomous Workflows 课程共包含 6 节课。

本课时的部分内容尚未翻译，以英文显示。

Agents That Think Twice

Ever wished your AI agent could check its own work? That's exactly what self-correction and reflection agents do!

These agents are designed to not just generate an output, but also to critically evaluate it and make improvements. Think of it as an agent having an internal "editor" or "critic".

The Reflective Cycle

The core idea of reflection is an iterative process:

Generate: The agent produces an initial response or action.
Reflect: It then uses another prompt (or a different LLM) to analyze its own output against specific criteria.
Refine: Based on the reflection, the agent adjusts its original output, aiming for better quality or accuracy.

This cycle can repeat multiple times until a satisfactory result is achieved.

Inside a Reflection Agent

A self-correcting agent typically involves a few key parts:

Generator LLM: The primary Large Language Model that creates the initial output.
Critic/Reflector LLM: Often the same LLM, but prompted to act as a critic, evaluating the generator's output.
Reflection Prompt: A carefully designed prompt that guides the critic LLM on what to evaluate and how.
Refinement Mechanism: The logic that takes the critic's feedback and uses it to improve the next generation.

The Generator Prompt

Just like any LLM interaction, a clear initial prompt for the "generator" is crucial. This prompt tells the agent what task to perform.

For example, if we want an agent to write a short story, the generator prompt would define the story's theme, characters, and length. The goal is a solid first draft.

prompt_template = "Write a 3-sentence story about a brave knight and a dragon."

Crafting the Reflection Prompt

The reflection prompt is where the magic happens. It instructs the LLM to review the previous output and identify areas for improvement.

This prompt should include specific criteria. For our story example, it might ask: "Is the story engaging? Does it clearly mention a knight and a dragon? Is it exactly 3 sentences?"

reflection_prompt = "Critique the following story: '{story}'. Does it meet these criteria: 1. Engaging? 2. Knight and Dragon present? 3. Exactly 3 sentences? Provide specific feedback for improvement."

Simple Reflection Example

Let's trace our story example conceptually:

Generate: LLM writes an initial story draft.
Reflect: LLM reads the story and the reflection prompt, then gives feedback (e.g., "It's 4 sentences, not 3.").
Refine: The agent receives the feedback. It then tries to rewrite the story, incorporating the feedback (e.g., shortening it to 3 sentences).

This loop continues until the story meets all criteria or a limit is reached.

Building a Refinement Loop

In practice, the refinement process often involves a loop. The agent continues to generate and reflect until a set condition is met. This condition could be:

A maximum number of iterations.
The reflection feedback indicates no further improvements are needed.
A specific quality metric is achieved.

This iterative process allows for continuous self-improvement, making agents more robust.

Code: A Simple Reflection Loop

Here's a simplified Python example demonstrating a basic self-correction loop. We'll use a placeholder LLM for clarity, focusing on the generate, reflect, and refine logic.

class MockLLM:
    def __init__(self):
        pass

    def generate_initial_output(self, task_prompt):
        # Simulate a generator LLM that sometimes gets it wrong
        if "start with 'Hello'" in task_prompt:
            return "Greetings! How are you?" # Incorrect initial attempt
        return "Hello World!" # Correct initial attempt based on prompt

    def reflect_and_suggest(self, original_task, generated_output):
        # Simulate a critic LLM
        reflection_prompt = (
            f"Given the task: '{original_task}'. "
            f"The generated output was: '{generated_output}'. "
            "Critique this output: Does it start with 'Hello'? "
            "If not, suggest a correction. Be concise."
        )
        # Simplified reflection logic for the mock LLM
        if not generated_output.strip().startswith("Hello"):
            return "Doesn't start with 'Hello'. Suggestion: Start with 'Hello'."
        return "Output meets criteria."

# --- Main Logic ---
llm = MockLLM()
task = "Create a greeting sentence that starts with 'Hello'."
current_output = llm.generate_initial_output(task)

print(f"Initial Output: {current_output}")

for i in range(3): # Max 3 attempts (initial + 2 refinements)
    reflection = llm.reflect_and_suggest(task, current_output)
    print(f"Reflection {i+1}: {reflection}")

    if "Output meets criteria" in reflection:
        print("Agent self-corrected successfully!")
        break
    else:
        # Simulate applying the suggestion
        if "Start with 'Hello'" in reflection and not current_output.startswith("Hello"):
            current_output = "Hello" + current_output[current_output.find(' '):] # Simple fix
            print(f"Refined Output: {current_output}")
        else:
            print("No specific refinement strategy for this feedback. Stopping.")
            break
print("\nFinal Output:", current_output)

Benefits & Trade-offs

Reflection agents are powerful for tasks requiring high accuracy or complex reasoning, especially when a single pass might miss nuances.

Improved Accuracy: Reduces errors and hallucinations.
Robustness: Handles complex prompts better.
Quality: Leads to higher-quality outputs.

However, they increase computational cost and latency due to multiple LLM calls. Use them where quality justifies the overhead.

Test Your Knowledge

Consider an agent designed to summarize a document and then self-correct. What is the primary purpose of the "reflection prompt" in this scenario?

在交互式课程中回答

Recap: Self-Correction

We've explored how self-correction and reflection agents work. These agents enhance AI capabilities by allowing them to critically evaluate and refine their own outputs.

They follow a generate, reflect, refine cycle.
Key components include a generator, a critic, and specific reflection prompts.
While increasing cost and latency, they significantly boost output quality and accuracy for complex tasks.

This ability to "think twice" is a crucial step towards more robust and intelligent AI systems!

免费开始

用 AI 导师学习 AI Agents with LangChain & Autonomous Workflows — 免费

在浏览器中编写并运行真实代码，获得全天候 AI 导师的即时帮助，并在网页或应用中继续学习。

课程: 12
课程: 50

免费开始学习查看完整课程

常见问题解答

「自我纠正与反思型智能体」课时是免费的吗？

是的 — 「自我纠正与反思型智能体」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 AI Agents with LangChain & Autonomous Workflows 课程的其余内容，请升级到 CoddyKit PRO。 AI Agents with LangChain & Autonomous Workflows 课程共包含 6 节课。

「自我纠正与反思型智能体」这节课中我会学到什么？

学习构建能够批判性评估自身输出，并反复改进响应或行动的智能体你通过在浏览器中直接运行的动手代码来练习 AI Agents with LangChain & Autonomous Workflows，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 AI Agents with LangChain & Autonomous Workflows 需要有经验吗？

无需任何先前经验。CoddyKit 上的 AI Agents with LangChain & Autonomous Workflows 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 3 节课，共 6 节。

「自我纠正与反思型智能体」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 AI Agents with LangChain & Autonomous Workflows 课中编写并运行代码吗？

能。每节 AI Agents with LangChain & Autonomous Workflows 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 AI Agents with LangChain & Autonomous Workflows