AI Agent 核心概念

什么是 AI Agent

AI Agent（智能体）是一种能够感知环境、自主规划并采取行动以完成目标的 AI 系统。与传统的单次 LLM 调用不同，Agent 具备持续迭代、使用工具、保持状态的能力。它不只是"回答问题"，而是"完成任务"。

感知—规划—行动 循环

所有 Agent 本质上都运行在一个三阶段循环中。理解这个循环，就理解了 Agent 的运作机制：

三大主流 Agent 架构对比

理解三种架构的设计哲学，才能在具体业务场景中做出正确选型：

ReAct 范式代码实现

ReAct 的核心是：让 LLM 输出带 Thought/Action/Observation 格式的文本，解析后执行对应工具：

import anthropic
import json
from typing import Callable, Dict

client = anthropic.Anthropic()

# ── 工具定义：给 LLM 描述可用工具 ──────────────────────────
TOOLS = [
    {
        "name": "search_web",
        "description": "搜索互联网获取最新信息。用于查找事实、新闻、技术文档。",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {"type": "string", "description": "搜索查询词"}
            },
            "required": ["query"]
        }
    },
    {
        "name": "calculate",
        "description": "执行数学计算。用于算术、统计等精确计算。",
        "input_schema": {
            "type": "object",
            "properties": {
                "expression": {"type": "string", "description": "数学表达式，如 '2 ** 10'"}
            },
            "required": ["expression"]
        }
    }
]

# ── 模拟工具实现 ─────────────────────────────────────────
TOOL_IMPL: Dict[str, Callable] = {
    "search_web": lambda query: f"[搜索结果] {query}: 找到3篇相关文章...",
    "calculate": lambda expression: str(eval(expression, {"__builtins__": {}}))
}

def run_react_agent(user_query: str, max_iterations: int = 10) -> str:
    """ReAct Agent 主循环：思考→行动→观察，直到完成。"""
    messages = [{"role": "user", "content": user_query}]

    for iteration in range(max_iterations):
        # 调用 LLM，允许工具调用
        response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=4096,
            tools=TOOLS,
            messages=messages
        )

        # 检查是否结束：stop_reason == "end_turn" 且没有工具调用
        if response.stop_reason == "end_turn":
            # 提取最终文字回复
            for block in response.content:
                if hasattr(block, "text"):
                    return block.text
            return "任务完成（无文字输出）"

        # stop_reason == "tool_use"：执行工具调用
        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                tool_name = block.name
                tool_input = block.input
                tool_id = block.id

                # 查找并执行对应工具实现
                if tool_name in TOOL_IMPL:
                    result = TOOL_IMPL[tool_name](**tool_input)
                else:
                    result = f"工具 {tool_name} 不存在"

                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": tool_id,
                    "content": result
                })

        # 将工具结果追加到消息历史，形成 ReAct 闭环
        messages.append({"role": "assistant", "content": response.content})
        messages.append({"role": "user", "content": tool_results})

    return "达到最大迭代次数，任务未完成"

# 使用示例
answer = run_react_agent("搜索 Python 3.12 的新特性，并计算如果有 5 个特性，每个特性占比多少")
print(answer)

Reflexion 架构：从错误中学习

Reflexion 的核心思想是：Agent 不仅要"做"，还要"反思"自己做得好不好，再"改进"：

def reflexion_agent(task: str, max_reflections: int = 2) -> str:
    """
    Reflexion 三阶段循环：
    1. Actor：生成初步答案（用工具执行任务）
    2. Evaluator：评估答案质量（LLM 或规则）
    3. Self-Reflection：生成改进建议
    然后用改进建议作为额外上下文，再次尝试
    """
    reflection_history = []  # 积累历次反思内容

    for attempt in range(max_reflections + 1):

        # ── Stage 1: Actor（执行任务）────────────────────────
        context = ""
        if reflection_history:
            # 将历次反思作为额外上下文传入
            context = "\n之前的尝试和反思：\n" + "\n".join(reflection_history)

        actor_response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=2000,
            messages=[{"role": "user",
                       "content": f"{context}\n\n任务：{task}"}]
        )
        current_answer = actor_response.content[0].text

        # ── Stage 2: Evaluator（评估质量）────────────────────
        if attempt == max_reflections:
            break  # 最后一次不再反思，直接返回

        eval_response = client.messages.create(
            model="claude-sonnet-4-6",
            max_tokens=500,
            messages=[{"role": "user",
                       "content": f"""评估以下答案的质量（0-10分），并指出具体不足：
任务：{task}
答案：{current_answer}

评估标准：准确性、完整性、逻辑清晰度
请简洁回答评分和改进方向（不超过100字）："""}]
        )
        evaluation = eval_response.content[0].text

        # 如果评分高（包含 "9" 或 "10"），提前终止
        if "9" in evaluation[:20] or "10" in evaluation[:20]:
            break

        # ── Stage 3: Self-Reflection（生成改进建议）─────────
        reflection = f"第{attempt+1}次尝试答案：{current_answer[:200]}...\n评估：{evaluation}"
        reflection_history.append(reflection)

    return current_answer

Agent 与 Chain 的本质区别

很多初学者混淆 LangChain 的 Chain（链）与 Agent（智能体），理解二者区别对于正确选型至关重要：

Agent 的能力边界

理解 Agent 的局限性与理解其能力同样重要，这避免过度设计和错误期望：

2024–2025 Agent 发展现状

近两年 Agent 领域经历了快速演进，以下是关键里程碑：

Agent 的五大组成要素

一个完整的 Agent 系统由以下核心组件构成。后续章节将逐一深入讲解每个组件：

# Agent 系统的五大核心组件（概念示意）
from typing import TypedDict
from langchain_anthropic import ChatAnthropic
from langgraph.graph import StateGraph

# ── 组件 1：LLM 推理引擎 — Agent 的"大脑" ──────────────
# temperature=0 提高确定性，适合需要精确工具调用的场景
llm = ChatAnthropic(model="claude-sonnet-4-6", temperature=0)

# ── 组件 2：工具集合 — Agent 的"手" ──────────────────
# 每个工具需要清晰的 name、description、参数 schema
tools = [search_web, run_python, query_database, send_email]
llm_with_tools = llm.bind_tools(tools)  # 将工具绑定到 LLM

# ── 组件 3：记忆系统 — Agent 的"记忆" ────────────────
# 短期记忆：当前会话的消息历史（存在 State 中）
# 长期记忆：跨会话的持久化知识（存在数据库/向量库中）

# ── 组件 4：状态管理 — Agent 的"工作台" ──────────────
# TypedDict 定义状态 schema，Reducer 控制更新方式
class AgentState(TypedDict):
    messages: list          # 用 add_messages reducer 自动追加
    current_task: str       # 当前正在处理的任务
    tools_called: list      # 已调用的工具记录（防循环用）
    iterations: int         # 当前迭代次数（安全阀）

# ── 组件 5：编排逻辑 — Agent 的"神经系统" ────────────
# 决定何时思考、何时行动、何时停止
# LangGraph 用图结构表达，比命令式代码更直观
graph = StateGraph(AgentState)
graph.add_node("reason", reasoning_node)   # 推理节点
graph.add_node("act", action_node)         # 执行节点
graph.add_conditional_edges(               # 条件路由
    "reason", should_act_or_finish
)