Agent 开发全流程：从概念到生产

Agent 开发全流程：从概念到生产

AI 核心技能系列 · 第 8 篇

---

导语

2026 年，Agent 是 AI 领域最热的方向，没有之一。

但"Agent"这个词被用得太泛了------ChatBot 是 Agent 吗？自动化脚本是 Agent 吗？一个套了 System Prompt 的聊天窗口就能叫 Agent 吗？

这篇文章帮你彻底搞清楚：Agent 到底是什么，主流架构模式有哪些，怎么选框架，以及------怎么从零开发一个能在生产环境跑的 Agent。

---

一、什么是 Agent：从概念到定义

1.1 核心定义

Agent 是能自主感知环境、做出决策、采取行动来完成任务的 AI 系统。

关键词是"自主"------你给它一个目标，它自己决定怎么实现，而不是你一步步告诉它做什么。

1.2 Agent vs ChatBot vs Workflow

维度	ChatBot	Workflow	Agent
决策方式	人主导对话	预设流程	AI 自主决策
灵活性	低（一问一答）	中（固定路径）	高（动态调整）
工具使用	不用/很少	预设顺序	按需选择
错误处理	依赖人类	预设分支	自主重试/换策略
复杂任务	不擅长	固定复杂度	开放式复杂任务
类比	客服接线员	流水线工人	独立负责项目的员工

1.3 Agent 的核心能力

┌─────────────────────────────────────────┐
│              Agent 核心架构               │
│                                           │
│         ┌──────────────┐                  │
│         │   感知 Perceive │                │
│         │ 理解环境和任务  │                │
│         └──────┬───────┘                  │
│                │                          │
│         ┌──────▼───────┐                  │
│         │  推理 Reason   │                │
│         │ 分析+规划方案  │                │
│         └──────┬───────┘                  │
│                │                          │
│         ┌──────▼───────┐    ┌──────────┐ │
│         │  行动 Act      │───│ 工具调用  │ │
│         │ 执行具体操作   │   │ API/DB.. │ │
│         └──────┬───────┘    └──────────┘ │
│                │                          │
│         ┌──────▼───────┐                  │
│         │  记忆 Memory   │                │
│         │ 积累经验教训   │                │
│         └──────────────┘                  │
│                                           │
│     ↻ 循环直到任务完成或达到限制            │
└─────────────────────────────────────────┘

---

二、Agent 的架构模式

2.1 四种主流模式

1. ReAct 模式（Reasoning + Acting）

推理和行动交替进行，最经典的 Agent 模式。

Thought: 用户想知道最新的 AI 论文，我需要搜索。
Action: search_arxiv("LLM agent 2026")
Observation: 找到 5 篇相关论文...
Thought: 需要筛选出最相关的 2 篇，总结要点。
Action: read_paper("2026.12345")
Observation: 论文主要讲...
Thought: 我有足够的信息来回答了。
Answer: 以下是最新的 AI Agent 研究进展...

2. Plan-and-Execute 模式

先制定完整计划，再按步骤执行。

Planning Phase:
  Step 1: 搜索最新 AI 论文
  Step 2: 筛选前 3 篇最相关的
  Step 3: 阅读并总结每篇要点
  Step 4: 整合成一份综述

Execution Phase:
  执行 Step 1... ✓
  执行 Step 2... ✓
  执行 Step 3... ✓（可能根据结果调整计划）
  执行 Step 4... ✓

3. 反思模式（Reflexion）

执行后自我评估，从错误中学习。

Action: 生成代码
Check: 运行测试 → 失败
Reflect: 分析错误原因，是边界条件没处理
Action: 修改代码，加上边界条件处理
Check: 运行测试 → 通过 ✓

4. 多 Agent 协作

多个专业化 Agent 分工合作。

Manager Agent
  ├── Research Agent（负责搜索和调研）
  ├── Coding Agent（负责写代码）
  ├── Review Agent（负责代码审查）
  └── Testing Agent（负责测试）

2.2 选择指南

模式	适用场景	复杂度
ReAct	大部分单 Agent 场景	★★
Plan-and-Execute	步骤明确的复杂任务	★★★
Reflexion	代码生成、写作等可验证任务	★★★
多 Agent	大型项目、需要不同专业能力	★★★★★

---

三、主流 Agent 框架对比

框架	出品	学习曲线	功能	特点
LangGraph	LangChain	★★★	★★★★★	状态图、最灵活
Claude Agent SDK	Anthropic	★★	★★★★	官方框架、集成好
CrewAI	社区	★★	★★★★	多 Agent 协作最简单
AutoGen	微软	★★★	★★★★	多 Agent 对话
Dify / Coze	各厂商	★	★★★	低代码、快速原型
纯代码	自己写	★★★★	∞	最灵活、理解原理

选择建议：

• 理解原理：先用纯代码实现一遍（本文会带你做）
• 快速原型：Dify / Coze
• 生产系统：LangGraph（复杂流程）或 Claude Agent SDK（Claude 生态）
• 多 Agent：CrewAI 或 AutoGen

---

四、实战：从零构建一个完整 Agent

不依赖任何框架，用纯 Python + OpenAI API 实现一个 ReAct Agent。

import json
import openai
from typing import Callable

client = openai.OpenAI()

# ===== 1. 定义工具 =====
def search_web(query: str) -> str:
    """模拟网页搜索"""
    # 实际项目中对接搜索 API
    return f"搜索'{query}'的结果: [模拟搜索结果]"

def calculate(expression: str) -> str:
    """安全的数学计算"""
    try:
        result = eval(expression, {"__builtins__": {}}, {})
        return str(result)
    except Exception as e:
        return f"计算错误: {e}"

def read_file(path: str) -> str:
    """读取文件内容"""
    try:
        with open(path) as f:
            return f.read()[:2000]
    except Exception as e:
        return f"读取失败: {e}"

# 工具注册表
TOOLS = {
    "search_web": search_web,
    "calculate": calculate,
    "read_file": read_file,
}

# OpenAI 工具定义
TOOL_DEFINITIONS = [
    {
        "type": "function",
        "function": {
            "name": "search_web",
            "description": "搜索互联网上的信息",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "搜索关键词"}
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "执行数学计算",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {"type": "string", "description": "数学表达式，如 '2+3*4'"}
                },
                "required": ["expression"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "read_file",
            "description": "读取本地文件的内容",
            "parameters": {
                "type": "object",
                "properties": {
                    "path": {"type": "string", "description": "文件路径"}
                },
                "required": ["path"]
            }
        }
    }
]

# ===== 2. Agent 核心循环 =====
SYSTEM_PROMPT = """你是一个智能助手，可以使用工具来完成任务。
请仔细分析用户的需求，选择合适的工具，逐步完成任务。
如果工具返回的结果不理想，可以尝试换一种方式。
当你有足够的信息回答用户问题时，直接给出最终回答。"""

def run_agent(user_message: str, max_iterations: int = 10):
    """Agent 主循环"""
    messages = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": user_message}
    ]
    
    for i in range(max_iterations):
        print(f"\n--- 迭代 {i+1} ---")
        
        # 调用 LLM
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            tools=TOOL_DEFINITIONS,
            tool_choice="auto",
        )
        
        message = response.choices[0].message
        messages.append(message)
        
        # 如果没有工具调用，说明 Agent 已经给出了最终回答
        if not message.tool_calls:
            print(f"最终回答: {message.content}")
            return message.content
        
        # 执行工具调用
        for tool_call in message.tool_calls:
            func_name = tool_call.function.name
            func_args = json.loads(tool_call.function.arguments)
            
            print(f"调用工具: {func_name}({func_args})")
            
            # 执行
            if func_name in TOOLS:
                result = TOOLS[func_name](**func_args)
            else:
                result = f"未知工具: {func_name}"
            
            print(f"工具结果: {result[:200]}")
            
            # 将结果加入对话
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": str(result)
            })
    
    return "达到最大迭代次数，任务未完成。"

# ===== 3. 运行 =====
if __name__ == "__main__":
    answer = run_agent("帮我搜索一下 2026 年最新的 AI Agent 框架，然后算一下如果每个框架学习需要 2 周，学完前 3 个需要多少天？")
    print(f"\n{'='*50}\n最终回答:\n{answer}")

这个 Agent 虽然简单，但已经具备了核心能力：

• 感知：理解用户问题
• 推理：决定用什么工具、按什么顺序
• 行动：调用工具获取信息
• 循环：根据结果决定下一步

---

五、生产部署注意事项

维度	措施
成本控制	Token 用量监控、设置 max_iterations 上限、用便宜模型做简单判断
延迟优化	流式输出、并行工具调用、缓存常见查询结果
可靠性	工具调用重试(3次)、超时处理(30s)、降级策略
可观测性	记录每轮的 thought/action/observation、追踪 Token 消耗
安全性	工具权限控制、沙箱隔离、高风险操作人工确认
评测	构建评测数据集，定期回归测试

---

六、职业视角

Agent 开发工程师是 2026 年最热门的技术岗位方向之一。

面试问题	核心答案要点
Agent 的核心架构？	感知-推理-行动-记忆循环
ReAct 的原理？	推理和行动交替，Thought→Action→Observation 循环
Agent 和 Workflow 的区别？	Agent 自主决策动态调整，Workflow 预设流程固定路径
怎么保证 Agent 的可靠性？	设置迭代上限、工具重试、错误降级、人工兜底

Agent 工程师 vs 传统后端工程师的核心差异：不确定性。传统后端的输入输出是确定的，Agent 的每一步都有不确定性------你必须学会设计"容错"和"兜底"的系统。

---

总结

1. Agent 定义：能自主决策、使用工具、完成复杂任务的 AI 系统
2. 架构模式：ReAct（最通用）、Plan-and-Execute（复杂任务）、Reflexion（可验证任务）、多 Agent（大型项目）
3. 框架选择：理解原理用纯代码，快速原型用 Dify，生产用 LangGraph/Claude SDK
4. 核心循环：LLM 决策 → 工具执行 → 结果反馈 → 继续或结束
5. 生产要点：成本、延迟、可靠性、可观测性、安全性缺一不可

---

本文是 AI 核心技能系列 第 8 篇，共 12 篇。上一篇：Fine-tuning 实战 | 下一篇：MCP 深入理解

关注公众号「coft」，获取完整系列更新、配套代码和学习路线图。一起交流 AI 转行经验，助力职业跃升，迈向高薪岗位。