CTO Plus技术服务栈
AI Agent LLM LangChain LangGraph AutoGen 智能体 Function Calling

AI Agent 开发实战：从原理到生产级智能体构建

从零构建AI智能体的完整指南：Agent架构设计、工具调用（Function Calling）、记忆系统、规划推理（Plan-and-Execute）、多Agent协作。包含LangChain/LangGraph/AutoGen实战案例。

SteveRocket
北京，中国
2 min read

从 Copilot 到 Agent 的范式转变

2025-2026 年，AI 行业最大的叙事变化是什么？不是模型变得更强了——虽然确实更强了——而是 AI 从”助手”变成了”代理”。

Copilot 模式：你告诉 AI 每一步做什么，AI 帮你执行。 Agent 模式：你告诉 AI 目标，AI 自己规划步骤、调用工具、处理异常，直到完成。

这个区别就像：

  • Copilot 是副驾驶，帮你操作方向盘，但路线还是你定
  • Agent 是自动驾驶，你说”去机场”，它自己规划路线、避开拥堵、找到停车位

我们团队在 2025 年下半年开始构建内部 Agent 系统，踩了不少坑。这篇文章把核心经验整理出来。

Agent 的核心能力

一个真正的 Agent 需要具备四项核心能力：

1. 推理与规划

Agent 需要理解复杂任务，并将其拆解为可执行的子任务。

比如”帮我做竞品分析”这个需求：

  • 人类大脑自动拆解：确定竞品列表 → 收集信息 → 分析对比 → 输出报告
  • Agent 也需要同样的能力，但它依赖 LLM 的推理来拆解

关键技术：

  • ReAct：Reasoning + Acting，交替进行思考和行动
  • Plan-and-Execute：先制定完整计划，再逐步执行
  • Tree of Thoughts：探索多个方案路径，选最优的

2. 工具使用

Agent 不能只靠”脑子”，还要有”手”——调用外部工具。

LLM 生成 → 工具调用请求 → 执行工具 → 结果返回 → LLM 继续推理

常见的工具类型：

  • 搜索工具：Google Search API、企业内部搜索
  • 代码执行：Python REPL、Shell 命令
  • API 调用：Jira 创建工单、Slack 发消息、数据库查询
  • 文件操作：读写文件、生成报告

3. 记忆系统

人类有短期记忆和长期记忆，Agent 也需要：

  • 工作记忆：当前对话上下文，知道刚才说了什么
  • 短期记忆：当前会话的历史，用于连贯的多轮交互
  • 长期记忆：跨会话的知识积累，用户偏好、历史决策

实现方式：

  • 工作记忆 → 上下文窗口
  • 短期记忆 → 摘要压缩 + 滑动窗口
  • 长期记忆 → 向量数据库 + 结构化存储

4. 反思与自我修正

好的 Agent 不是一次性输出结果，而是：

  1. 生成初步结果
  2. 自我审查：结果是否符合要求？是否有明显错误？
  3. 如果不符合，修正后重新输出
  4. 必要时向用户请求澄清

我们称之为”慢思考”模式——相比快速生成，多花几秒钟做自我审查，质量提升显著。

技术架构：LangGraph 实战

我们选择了 LangGraph 作为 Agent 框架，原因是它的**有状态图（StateGraph）**抽象非常适合 Agent 的决策流程。

基础结构

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
import operator

class AgentState(TypedDict):
    messages: Annotated[list, operator.add]
    next_step: str
    tool_results: dict

# 创建图
workflow = StateGraph(AgentState)

# 添加节点
workflow.add_node("agent", agent_node)       # LLM 推理
workflow.add_node("tools", tool_node)         # 工具执行
workflow.add_node("summarize", summarize_node) # 结果汇总

# 添加边
workflow.set_entry_point("agent")
workflow.add_conditional_edges(
    "agent",
    should_continue,  # 决策函数
    {
        "continue": "tools",
        "end": "summarize"
    }
)
workflow.add_edge("tools", "agent")
workflow.add_edge("summarize", END)

# 编译执行
app = workflow.compile()
result = app.invoke({"messages": [HumanMessage(content="帮我分析最近一周的系统错误日志")]})

核心节点设计

agent_node — 推理决策：

def agent_node(state: AgentState):
    """LLM 推理节点，决定下一步行动"""
    response = llm_with_tools.invoke(state["messages"])
    
    # 检查是否需要调用工具
    if response.tool_calls:
        return {
            "messages": [response],
            "next_step": "tools"
        }
    else:
        return {
            "messages": [response],
            "next_step": "summarize"
        }

tool_node — 工具执行：

def tool_node(state: AgentState):
    """执行工具调用"""
    last_message = state["messages"][-1]
    
    tool_results = []
    for tool_call in last_message.tool_calls:
        tool = tools_by_name[tool_call["name"]]
        result = tool.invoke(tool_call["args"])
        tool_results.append(
            ToolMessage(content=str(result), tool_call_id=tool_call["id"])
        )
    
    return {"messages": tool_results}

条件路由

Agent 最核心的能力是动态决策——根据当前状态决定下一步：

def should_continue(state: AgentState):
    """决定是继续调用工具还是结束"""
    last_message = state["messages"][-1]
    
    # 如果 LLM 要求调用工具
    if hasattr(last_message, "tool_calls") and last_message.tool_calls:
        return "continue"
    
    # 如果已经调用过工具且 LLM 不再要求
    return "end"

多 Agent 协作

单个 Agent 能力有限，复杂场景需要多个 Agent 协作。我们总结了三种协作模式：

模式一：顺序流水线

数据采集 Agent → 分析 Agent → 报告生成 Agent

适合流程固定的场景。每个 Agent 专注于一个环节，输出是下一个的输入。

模式二：主管-工人模式

        主管 Agent（分配任务、汇总结果）
        /        |        \
    工人A      工人B      工人C
  （搜索）   （分析）   （编码）

主管 Agent 理解用户需求，将子任务分配给不同的专家 Agent，最后汇总结果。这是 AutoGen 框架的核心模式。

模式三：辩论模式

Agent A 观点 ←→ Agent B 观点
        ↘    ↙
      评判 Agent

多个 Agent 针对同一问题给出不同答案，通过辩论达成一致。适合需要严谨推理的场景。

多 Agent 实战：AutoGen 示例

from autogen import AssistantAgent, UserProxyAgent, GroupChat, GroupChatManager

# 创建专业 Agent
researcher = AssistantAgent(
    name="研究员",
    system_message="你是技术研究员，擅长收集和分析技术信息。",
    llm_config={"config_list": [gpt4_config]}
)

coder = AssistantAgent(
    name="程序员",
    system_message="你是高级程序员，擅长编写高质量代码。",
    llm_config={"config_list": [gpt4_config]}
)

reviewer = AssistantAgent(
    name="审查员",
    system_message="你是代码审查专家，找出代码中的问题和改进点。",
    llm_config={"config_list": [gpt4_config]}
)

# 创建用户代理
user_proxy = UserProxyAgent(
    name="用户",
    human_input_mode="NEVER",
    code_execution_config={"work_dir": "coding"}
)

# 创建群聊
group_chat = GroupChat(
    agents=[user_proxy, researcher, coder, reviewer],
    messages=[],
    max_round=10
)

manager = GroupChatManager(groupchat=group_chat)

# 启动任务
user_proxy.initiate_chat(
    manager,
    message="设计并实现一个分布式ID生成器，要求高性能、趋势递增"
)

生产级 Agent 的关键挑战

挑战一：可控性

Agent 的自由度越高，不可预测性越大。你没法保证它不会：

  • 调用错误的工具
  • 陷入死循环
  • 产生不安全的操作

我们的解决方案：

  1. 操作分级：读操作自动执行，写操作需要确认，危险操作（删除、执行命令）必须人工审批
  2. 预算控制：设置最大步数、最大 Token 消耗、最大执行时间
  3. 人工介入点：在关键决策点插入人工确认
class SafeAgent:
    def execute_action(self, action):
        if action.risk_level == "LOW":
            return self._auto_execute(action)
        elif action.risk_level == "MEDIUM":
            return self._confirm_and_execute(action)
        elif action.risk_level == "HIGH":
            return self._require_approval(action)

挑战二：可靠性

LLM 有时会产生不符合预期的输出格式，导致 Agent 流程中断。

我们的解决方案：

  1. 结构化输出：使用 Function Calling 或 JSON Mode 强制格式
  2. 重试机制：输出解析失败时自动重试（附带错误信息）
  3. 降级策略：多次失败后降级为简单模式或转人工
def safe_invoke_with_retry(llm, messages, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = llm.invoke(messages)
            return parse_output(response)
        except ParseError as e:
            if attempt == max_retries - 1:
                raise
            messages.append({
                "role": "user",
                "content": f"输出格式错误：{e}。请按照正确格式重新输出。"
            })

挑战三：成本控制

Agent 可能在一个任务上消耗大量 Token，尤其是需要多轮工具调用的场景。

优化策略：

  • 模型分级：简单推理用小模型（GPT-4o-mini），复杂推理用大模型（GPT-4o / Claude 3.5）
  • 缓存利用：相同的系统提示和工具定义缓存起来
  • 早停机制：达到满意结果就停止，不追求”完美”
  • 并发控制：限制同时运行的 Agent 数量

挑战四：评估与监控

Agent 不像传统软件有明确的正确/错误边界。如何知道 Agent 做得好不好？

我们的评估体系：

维度指标工具
任务完成率是否达到用户目标人工评估 + LLM-as-Judge
效率步数、时间、Token 消耗LangSmith / 自建监控
安全性是否执行了危险操作审计日志
用户满意度用户反馈评分内嵌评价

我们的实践经验

经验一：从简单场景开始

不要一上来就做全自动的复杂 Agent。我们的路径是：

  1. 单一工具 + 单轮对话：比如”搜索 + 回答”的客服 Agent
  2. 多工具 + 固定流程：比如”分析日志 → 生成报告”的运维 Agent
  3. 多 Agent + 动态流程：比如”需求分析 → 方案设计 → 代码生成 → 审查”的研发 Agent

每个阶段跑稳定了再进入下一阶段。

经验二：工具定义是门艺术

工具的描述直接影响 Agent 的决策质量。描述要包含：

  • 功能：这个工具做什么
  • 场景：什么时候该用它
  • 参数说明：每个参数的含义和约束
  • 反例：什么情况下不应该用它
# 好的工具描述
{
    "name": "search_knowledge_base",
    "description": "在企业知识库中搜索技术文档。当用户询问公司内部的技术规范、架构设计、运维手册时使用。不要用于搜索外部信息或通用知识。",
    "parameters": {
        "query": "搜索关键词，建议使用技术术语而不是自然语言问题",
        "max_results": "返回结果数量，默认5，最多20"
    }
}

经验三：记忆管理要分层

不要把什么信息都塞进上下文窗口：

  • 频繁变化的（当前对话状态）→ 上下文窗口
  • 会话内不变的（用户身份、偏好）→ 变量注入
  • 跨会话的（历史决策、知识积累）→ 外部存储

总结

AI Agent 是 2026 年最值得投入学习的技术方向之一。核心要点：

  1. Agent = LLM + 规划 + 工具 + 记忆 + 反思
  2. LangGraph 提供了优雅的状态图抽象，适合复杂 Agent 流程
  3. 多 Agent 协作是解决复杂问题的关键
  4. 生产落地要关注可控性、可靠性、成本和评估
  5. 从简单场景开始迭代，不要追求一步到位

未来的软件架构中，Agent 不是一个可选的附加组件，而是一种新的编程范式。

Comments

Link copied to clipboard!