简简单单 Online zuozuo ：本心、输入输出、结果
文章目录
构建能够从失败中学习的自进化AI代理
编辑 | 简简单单 Online zuozuo
地址 | https://blog.csdn.net/qq_15071263
如果觉得本文对你有帮助，欢迎点赞、收藏、评论，谢谢
前言
对于构建自主系统的开发者来说，当今的生成式AI代理面临一个根本性挑战：它们患有"健忘症"。一个代理可以执行复杂的任务，失败，然后重复同样的错误。对于试图构建可靠自主系统的开发者和架构师来说，这是采用的主要障碍。一个不可靠的代理不是自主的，而是一个脆弱的系统，会产生技术债务。
这就是为什么AI的真正前沿不仅仅是构建更大的模型，而是创建能够学习的代理。本文将向您展示如何在Python中构建一个简单的自进化代理。
我们可以将推理库（ReasoningBank）视为策略的检索增强生成（RAG），而不是数据。与获取静态文档不同，代理检索从失败中提炼出的高级推理模式。
#AI代理 #自进化系统 #Python开发 #机器学习 #自主系统 #失败学习 #推理库 #智能代理
1、问题：静态、脆弱的代理
当今的LLM代理将核心模型与规划模块和工具相结合，使它们容易受到错误传播的影响。单个根本原因错误，例如误用工具或调用不可靠的API，可能导致整个任务链失败。这使得它们不适合定义真实世界价值的"长期视野"技术挑战，例如管理软件项目、进行复杂数据分析或自动化多步骤DevOps流程。
2、实用解决方案：在Python中构建"推理库"
让我们构建一个不再重复犯同样错误的代理。核心机制涉及从健忘症到经验的转变，通过持久化和结构化的记忆来促进。与将每个错误视为独立事件不同，我们的代理会从失败中学习，并将这些经验转化为可重用的策略。
3、步骤1：定义一个相关任务
在构建大脑之前，让我们先定义工作。我们需要一个模拟真实世界场景的任务，比如从项目管理API获取数据。
在理想情况下，这个函数总是能正常工作。在我们的模拟中，它是"不稳定的"。它在特定条件下失败（过期的密钥或坏的主机），这迫使我们的代理适应。
python
def call_external_api(project_id, api_key, host):
"""模拟一个不稳定的外部API调用"""
if api_key == "old-key-xyz":
raise ValueError("Invalid API Key")
if host == "bad-host.example.com":
raise ConnectionError("Host unreachable")
return {"status": "success", "data": f"Data for project {project_id}"}
4、步骤2：记忆（推理库）
现在我们需要一个地方来存储经验教训。这个简单的类将洞察保存到本地JSON文件，这样即使脚本重启，代理也能记住它们。
python
import json
import os
class ReasoningBank:
def __init__(self, file_path="reasoning_bank.json"):
self.file_path = file_path
self.lessons = self._load_lessons()
def _load_lessons(self):
if os.path.exists(self.file_path):
with open(self.file_path, 'r') as f:
return json.load(f)
return []
def save_lesson(self, project_id, error_type, root_cause, strategy):
lesson = {
"project_id": project_id,
"error_type": error_type,
"root_cause": root_cause,
"strategy": strategy
}
self.lessons.append(lesson)
with open(self.file_path, 'w') as f:
json.dump(self.lessons, f, indent=2)
def get_lessons_for_project(self, project_id):
return [lesson for lesson in self.lessons if lesson["project_id"] == project_id]
5、步骤3：大脑（反思）
这个函数是最关键的组件。它将原始错误文本转换为可操作的策略。这是记录错误和理解错误之间的区别。
python
def reflect_on_failure(error_message, project_id, reasoning_bank):
"""分析失败并提取可重用的策略"""
error_lower = error_message.lower()
if "invalid api key" in error_lower or "api key" in error_lower:
root_cause = "Invalid API Key"
strategy = {
"type": "replace_param",
"param": "api_key",
"value": "new-key-abc"
}
elif "connection" in error_lower or "host" in error_lower or "unreachable" in error_lower:
root_cause = "Host Connection Error"
strategy = {
"type": "skip_task",
"reason": "Host is down"
}
else:
root_cause = "Unknown Error"
strategy = {
"type": "retry",
"max_attempts": 3
}
reasoning_bank.save_lesson(project_id, type(error_message).__name__, root_cause, strategy)
return strategy
6、步骤4：代理结构
最后，我们组装代理。它的execute_task方法被包装在逻辑中，在执行之前检查推理库。
python
class SelfEvolvingAgent:
def __init__(self, reasoning_bank):
self.reasoning_bank = reasoning_bank
def create_plan(self, task):
"""在创建计划之前，检查是否有相关的经验教训"""
project_id = task.get("project_id")
lessons = self.reasoning_bank.get_lessons_for_project(project_id)
if lessons:
latest_lesson = lessons[-1]
strategy = latest_lesson["strategy"]
if strategy["type"] == "replace_param":
task[strategy["param"]] = strategy["value"]
print(f"应用策略：将{strategy['param']}替换为{strategy['value']}")
elif strategy["type"] == "skip_task":
print(f"跳过任务：{strategy['reason']}")
return None
return task
def execute_task(self, task):
plan = self.create_plan(task)
if plan is None:
return {"status": "skipped", "reason": "基于经验教训跳过"}
try:
result = call_external_api(
plan["project_id"],
plan["api_key"],
plan["host"]
)
return {"status": "success", "result": result}
except Exception as e:
print(f"执行失败：{str(e)}")
strategy = reflect_on_failure(str(e), plan["project_id"], self.reasoning_bank)
return {"status": "failed", "error": str(e), "strategy": strategy}
7、整合：执行流程
现在我们可以实时观察代理学习。我们将执行代码与代理的推理过程交织在一起。
第一次尝试
代理尝试使用old-key-xyz执行task_1。call_external_api函数抛出ValueError。except块捕获了这个错误。
python
# 初始化
reasoning_bank = ReasoningBank()
agent = SelfEvolvingAgent(reasoning_bank)
# 任务1：第一次尝试
task_1 = {
"project_id": "project-1",
"api_key": "old-key-xyz",
"host": "api.example.com"
}
result = agent.execute_task(task_1)
print(result)
# 输出：执行失败：Invalid API Key反思和记忆：reflect_on_failure()函数被触发。它分析错误消息，识别根本原因（"Invalid API Key"），并创建一个带有"replace_param"策略的结构化经验教训。
第二次尝试
代理被要求重新执行task_1。这次，create_plan()查询推理库并检索经验教训。它通过修改任务以使用new-key-abc来应用策略，执行成功。
python
# 任务1：第二次尝试（使用相同的任务定义）
result = agent.execute_task(task_1)
print(result)
# 输出：应用策略：将api_key替换为new-key-abc
# {'status': 'success', 'result': {'status': 'success', 'data': 'Data for project project-1'}}第三次尝试
代理尝试一个新任务task_2。这个项目主机遇到不同的错误（ConnectionError）。代理没有这个项目的先前经验教训，所以它尝试执行并失败。
python
# 任务2：第一次尝试
task_2 = {
"project_id": "project-2",
"api_key": "valid-key",
"host": "bad-host.example.com"
}
result = agent.execute_task(task_2)
print(result)
# 输出：执行失败：Host unreachable反思和记忆：代理反思并创建一个新的经验教训，使用"skip_task"策略，因为主机已关闭。
第四次尝试
在第四次尝试中，规划器看到这个"skip_task"经验教训，决定不尝试执行任务。这节省了时间和计算资源。
python
# 任务2：第二次尝试（使用相同的任务定义）
result = agent.execute_task(task_2)
print(result)
# 输出：跳过任务：Host is down
# {'status': 'skipped', 'reason': '基于经验教训跳过'}
8、结论
通过从静态、健忘的代理转向能够学习的动态系统，我们打开了真正自主的大门。区别在于一个简单的持久化JSON文件和一个reflect_on_failure函数。
这是从脆弱的黑盒工具到自适应、弹性系统的转变。这是一个您可以信任的系统，可以管理CI/CD管道，而不仅仅是运行单个脚本，正是因为它有记忆。通过将失败转化为策略，我们将错误从障碍转变为构建块。
生如逆旅，一苇以航
我们应该静下心来，放下浮躁，不必有太着急的心态，把一件事情做好
感谢亲的点赞、收藏、评论，一键三连支持，谢谢
