疯狂熬夜三个月做出AI Agent，不是你以为的套壳

疯狂熬夜三个月，我终于把AI Agent做成了：这不是你以为的「套壳」

核心概念：AI Agent到底是什么？

很多人第一次听到“AI Agent”这个词，第一反应可能是：这不就是套个API壳吗？如果你也这么想，那接下来的内容，多半会碘伏你的认知。

AI Agent的本质，是让大模型具备自主规划、工具调用、长期记忆和环境交互的能力。传统AI调用是“一问一答”模式——你问，它答，结束。而Agent模式下，大模型可以做到：

• 自主规划任务步骤：把一个复杂目标拆解成多个子任务
• 调用外部工具：搜索、计算、读写文件、执行代码
• 长期记忆：跨会话积累上下文和学习经验
• 环境交互：感知环境变化并调整行为

用一个类比来解释：如果传统AI是一个只会背书的实习生，那AI Agent就是一个能独立完成项目的项目经理。它不只是回答问题，而是能够主动发现问题、解决问题、交付结果。

技术架构：拆解AI Agent的四大核心模块

一个完整的AI Agent通常由四个核心模块组成：

┌─────────────────────────────────────────────────────────┐
│AI Agent │
├─────────────────────────────────────────────────────────┤
│┌─────────────┐┌─────────────┐┌─────────────┐ │
││ Planning││ Memory││ Tools │ │
││ 规划模块 ││ 记忆模块 ││ 工具模块 │ │
│└──────┬──────┘└──────┬──────┘└──────┬──────┘ │
│ │││
│││ └────────────────┼────────────────┘│
│││
│││ ┌──────▼──────┐│
│││ │ Core││
│││ │ LLM Engine ││
│││ └─────────────┘ │
└─────────────────────────────────────────────────────────┘

规划模块：负责将复杂任务拆解为可执行的步骤。常见实现包括：

• ReAct：让模型在推理过程中交替进行思考和行动
• CoT：通过链式思考逐步推导
• MoA：多Agent协作分工

记忆模块：分为三种类型：短期记忆（当前会话上下文）、长期记忆（跨会话积累的知识）、工作记忆（任务执行过程中的临时信息）。

工具模块：Agent调用外部能力的接口，包括搜索工具、代码执行、文件读写、API调用等。

核心引擎：负责理解、推理、决策的大脑。

深度拆解：ReAct范式与AutoGPT的核心原理

理解了架构之后，来看两个最核心的技术实现：ReAct范式和AutoGPT。

ReAct：让大模型学会“边想边做”

ReAct是在实战中使用最频繁的框架。核心思想是让大模型在推理过程中交替进行“思考”和“行动”。

传统的CoT只让模型“想”，不让它“做”。而ReAct让模型在每个推理步骤后追加一个行动，通过观察行动结果来调整下一步推理。

# ReAct核心逻辑伪代码
def react_loop(query, agent):
history = []
observation = ""
while not finished:
# 思考步骤：基于当前状态生成推理
thought = agent.think(query, history, observation)
# 行动步骤：决定下一步动作
action = agent.decide_action(thought)
# 执行动作并获取结果
observation = agent.execute(action)
# 记录历史
history.append({"thought": thought, "action": action, "observation": observation})
# 检查是否达成目标
if agent.is_goal_achieved(observation):
finished = True
return agent.generate_response(history)

关键在于decide_action函数，它需要让模型学会：当前状态是什么？有哪些可用工具？下一步最合适的行动是什么？这需要精心设计的prompt工程。

值得分享一个常用的ReAct prompt模板：

SYSTEM_PROMPT = """
你是一个专业的AI助手，擅长将复杂任务拆解并逐步执行。在每个步骤中，你需要：
1. 思考（THINK）：分析当前情况，明确已知信息和目标
2. 行动（ACT）：从以下可选行动中选择最合适的：
- search[关键词]：使用搜索引擎查找信息
- calculate[表达式]：进行数学计算
- read[文件路径]：读取本地文件内容
- write[内容]：写入文件
- execute[代码]：执行代码
- finish：任务完成，生成最终回答
每次只选择一个行动。行动执行后，你会获得观察结果（OBSERVATION）。基于观察结果，继续下一步的思考和行动。
示例：
用户: 北京今天气温多少度？
THINK: 用户想知道北京今天的气温。需要搜索最新的北京天气信息。
ACT: search[北京今天气温]
OBSERVATION: 搜索结果显示北京今天气温15-23度，多云。
THINK: 获得了北京今天的气温信息，可以回答用户了。
ACT: finish[北京今天气温15-23度，多云]
"""

AutoGPT：从“自动”到“自主”的跨越

AutoGPT是2023年最具影响力的开源Agent项目之一。它的核心创新在于引入了自主目标分解和递归任务执行。

传统的ReAct需要人类指定每个步骤，而AutoGPT可以让模型自己生成子目标，形成一个任务树：

class AutoGPT:
def __init__(self, model, tools):
self.model = model
self.tools = tools
self.goals = []

def run(self, initial_goal):
self.goals = [Task(initial_goal, priority=1)]
completed_tasks = []
while self.goals:
self.goals.sort(key=lambda x: x.priority)
current_task = self.goals.pop(0)
result = self.execute_task(current_task)
subtasks = self.analyze_and_decompose(result)
for subtask in subtasks:
self.goals.append(subtask)
completed_tasks.append(current_task)
return self.generate_final_output(completed_tasks)

def execute_task(self, task):
prompt = f"""任务：{task.description}
目标：{task.goal}
请执行任务。如果任务复杂，可以分解为多个子任务。
子任务格式：subtask[描述]|priority[优先级]
执行结果："""
response = self.model.generate(prompt)
if "subtask[" in response:
subtasks = self.parse_subtasks(response)
return {"status": "decomposed", "subtasks": subtasks}
else:
return {"status": "completed", "result": response}

AutoGPT的另一个关键特性是目标回溯：如果某个子任务失败，它会自动分析原因并尝试替代方案，这使得整个系统具有很强的容错能力。

实战：从零构建一个自动写周报的Agent

光说不练假把式。接下来，从零构建一个自动写周报的Agent。这个Agent需要：读取本周的工作记录（从钉钉/飞书导出），分析并分类工作内容，生成结构化的周报。

第一步：定义工具集

from dataclasses import dataclass
from typing import List, Dict, Callable

@dataclass
class Tool:
name: str
description: str
function: Callable
parameters: Dict

class ToolRegistry:
def __init__(self):
self.tools: List[Tool] = []
def register(self, name, description, func, params):
self.tools.append(Tool(name, description, func, params))
def get_tool(self, name):
for tool in self.tools:
if tool.name == name:
return tool
raise ValueError(f"Tool {name} not found")
def list_tools(self):
return "\n".join([f"- {t.name}: {t.description} (参数: {', '.join(t.parameters)})" for t in self.tools])

# 注册工具
registry = ToolRegistry()
registry.register(name="read_file", description="读取本地文件内容", func=read_file_content, params=["file_path"])
registry.register(name="search_web", description="搜索互联网获取信息", func=search_internet, params=["query"])
registry.register(name="sa ve_file", description="保存内容到本地文件", func=sa ve_to_file, params=["content", "file_path"])

第二步：实现Agent核心

class WeeklyReportAgent:
def __init__(self, llm, tool_registry):
self.llm = llm
self.tools = tool_registry
self.conversation_history = []
self.short_term_memory = []

def system_prompt(self):
tools_desc = self.tools.list_tools()
return f"""你是一个专业的周报撰写助手。
## 工作流程
1. 首先收集信息：读取工作记录文件
2. 分析整理：分类本周工作内容
3. 生成周报：按照标准格式撰写
## 输出格式
周报需要包含：
- 本周完成（3-5条）
- 进行中（1-3条）
- 下周计划（3-5条）
- 心得总结（1条）
## 注意事项
- 数据必须来自实际文件，不要编造
- 语言简洁专业，突出价值
"""

def think(self, user_input):
context = self.build_context()
prompt = f"{self.system_prompt()}当前任务：{user_input}{context}请进行THINK，分析当前状态，然后决定ACT。"
response = self.llm.generate(prompt)
self.conversation_history.append({"role": "assistant", "content": response})
return response

def act(self, thought):
if "read_file" in thought:
file_path = extract_path(thought)
result = self.tools.get_tool("read_file").function(file_path)
return f"已读取文件 {file_path}", result
elif "sa ve_file" in thought:
return "保存文件", "success"
elif "finish" in thought or "完成" in thought:
return "FINISH", None
return "继续执行", None

def run(self, initial_task, max_iterations=10):
current_input = initial_task
iteration = 0
while iteration < max_iterations:
thought = self.think(current_input)
action_result = self.act(thought)
self.short_term_memory.append({"iteration": iteration, "thought": thought, "action_result": action_result})
if action_result[0] == "FINISH":
return self.generate_final_report()
current_input = f"观察结果：{action_result[0]}"
iteration += 1
return "执行超时，请检查任务设置"

第三步：完整运行示例

# 初始化
llm = OpenAIClient(model="gpt-4o")
registry = ToolRegistry()
register_work_tools(registry)
agent = WeeklyReportAgent(llm, registry)

task = "请读取 weekly_logs.txt 文件，分析本周工作内容，生成周报"
report = agent.run(task)
print(report)

实际运行效果：

=== Agent 执行日志 ===
步骤 0: THINK - 用户需要生成周报。需要先读取工作记录文件。
步骤 0: ACT - read_file[weekly_logs.txt]
观察结果：已读取文件，包含15条工作记录
步骤 1: THINK - 已获得工作记录，需要分析并分类
步骤 1: ACT - 分析完成，识别出：项目A开发、代码Review、周会参与等
步骤 1: ACT - finish[生成周报...]
=== 最终周报 ===
## 本周完成
1. 完成用户模块API开发（3天）
2. 完成代码Review 8次
3. 参加产品评审会1次
## 进行中
1. 性能优化方案设计
## 下周计划
1. 上线用户模块
2. 开始订单模块开发
## 心得
本周重点完成了核心功能开发，对模块化设计有了更深的理解。

技术对比：主流Agent框架横评

市场上主流的Agent框架有很多，做一个横向对比：

从实际项目经验来看：快速原型用BabyAGI，概念简单上手快；复杂业务用LangChain，灵活性最强；软件开发则推荐MetaGPT，多Agent协作模式很适合代码生成。

核心挑战：为什么你的Agent总是“跑偏”？

做了三个月Agent，最常见的挑战是：Agent跑到一半开始“幻觉”，偏离目标。这里总结几个核心问题和解决方案。

问题一：上下文窗口耗尽

当任务复杂、步骤多的时候，上下文会快速膨胀，最终超过模型的上下文窗口限制。解决方案是实施记忆压缩和任务摘要。

def compress_context(memory, max_items=10):
if len(memory) <= max_items:
return memory
recent = memory[-max_items//2:]
early = memory[:-max_items//2]
summary = summarize_memories(early)
return [{"type": "summary", "content": summary}, *recent]

def summarize_memories(memories):
prompt = f"""将以下工作记录压缩为一个简洁的摘要：
{chr(10).join([m['thought'] for m in memories])}
要求：
- 保留关键决策和行动
- 移除重复信息
- 长度控制在100字以内"""
return llm.generate(prompt)

问题二：工具调用失败

网络不稳定、文件不存在、API超时等问题都可能导致工具调用失败。解决方案是实施重试机制和降级策略。

import time
from functools import wraps

def retry_with_backoff(max_retries=3, initial_delay=1):
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
delay = initial_delay
for attempt in range(max_retries):
try:
return func(*args, **kwargs)
except Exception as e:
if attempt == max_retries - 1:
raise
time.sleep(delay)
delay *= 2
return wrapper
return decorator

问题三：目标偏离

Agent在多步骤执行后，容易忘记最初的目标。解决方案是实施目标提醒和中间检查点。

def check_alignment(current_step, original_goal):
prompt = f"""当前执行步骤：{current_step}
原始目标：{original_goal}
判断执行是否偏离目标。如果偏离，返回原因和建议调整。
如果正常，返回"ALIGNED"。"""
response = llm.generate(prompt)
return "ALIGNED" in response

def execute_with_checkpoint(agent, step, goal):
result = execute_step(step)
if not check_alignment(result, goal):
correction = realign_goal(goal, result)
return correction
return result

架构图：复杂Agent系统的完整设计

下面是一个完整的复杂Agent系统架构图，展示了从用户输入到最终输出的完整流程：