从零搭建一个能调用 API 的 AI Agent

这个类本身没什么魔法，关键在于把 LLM 的生成结果当成分步指令，用工具去落地。如果某一步失败，就重新规划。

让 Agent 具备'思考-行动'循环：ReAct

更实际一点的框架是 ReAct（Reasoning + Acting），它会输出思考过程，再选择工具，观察结果，继续循环。

class ReActAgent:
    def __init__(self, llm, tools):
        self.llm = llm
        self.tools = {tool.name: tool for tool in tools}
        self.max_iterations = 10

    def run(self, task):
        context = f"任务：{task}\n"
        for i in range(self.max_iterations):
            thought = self._think(context)
            print(f"[思考] {thought}")
            if "任务完成" in thought or "Final Answer:" in thought:
                return self._extract_answer(thought)
            action, action_input = self._decide_action(thought)
            print(f"[行动] {action}({action_input})")
            observation = self._observe(action, action_input)
            print(f"[观察] {observation}")
            context += f"\n思考：{thought}\n行动：{action}({action_input})\n观察：{observation}"
        return "达到最大迭代次数，任务未完成"

    def _think(self, context):
        prompt = f""" {context} 请思考下一步应该做什么。如果任务已完成，请回答"任务完成：[结果]" """
        return self.llm.generate(prompt)

    def _decide_action(self, thought):
        response = self.llm.generate(f"根据思考'{thought}'，选择要执行的工具和参数")
        return self._parse_action(response)

    def _observe(self, action, action_input):
        if action in self.tools:
            return self.tools[action].execute(action_input)
        return f"未知工具：{action}"

    def _extract_answer(self, thought):
        return thought.split("任务完成：")[-1].strip()

    def _parse_action(self, response):
        lines = response.strip().split('\n')
        action = "default"
        action_input = ""
        for line in lines:
            if "工具：" in line or "tool:" in line.lower():
                action = line.split("：")[-1].strip()
            if "参数：" in line or "input:" in line.lower():
                action_input = line.split("：")[-1].strip()
        return action, action_input

配套的工具类可以很简单：

class FileTool:
    name = "file_tool"
    def execute(self, input_data):
        return f"文件操作完成：{input_data}"

class WebTool:
    name = "web_tool"
    def execute(self, input_data):
        return f"网络请求完成：{input_data}"

class MockLLM:
    def generate(self, prompt):
        if "思考" in prompt:
            return "我需要先搜索相关信息"
        elif "选择" in prompt:
            return "工具：web_tool\n参数：搜索 AI Agent"
        return "处理完成"

怎么用起来：从选模型到控制成本

模型选择

我现在通常这样看：

• 简单任务用性价比高的模型（比如 GPT-3.5 或国产小模型），响应快、便宜；
• 复杂推理或需要大量代码生成的场景，上 GPT-4 或 Claude；
• 数据敏感的本地部署就选 LLaMA 或 Qwen 系列。

评估效果

评估不仅仅是看跑通了多少个用例，还得关注步骤数和用户满意度。下面是一个简单的评估框架：

def evaluate_agent(agent, test_cases):
    metrics = {'success_rate': 0, 'avg_time': 0, 'avg_steps': 0, 'user_satisfaction': 0}
    results = []
    for case in test_cases:
        start = time.time()
        result = agent.execute(case['task'])
        elapsed = time.time() - start
        results.append({
            'success': result == case['expected'],
            'time': elapsed,
            'steps': len(agent.memory),
            'quality': rate_quality(result, case['expected'])
        })
    metrics['success_rate'] = sum(r['success'] for r in results) / len(results)
    metrics['avg_time'] = sum(r['time'] for r in results) / len(results)
    metrics['avg_steps'] = sum(r['steps'] for r in results) / len(results)
    metrics['user_satisfaction'] = sum(r['quality'] for r in results) / len(results)
    return metrics

成本控制

优化提示词以减少 token 消耗，用缓存避免重复调用；权限最小化，敏感操作需二次确认。

别踩这些坑

我曾见过一个团队为了'全面自动化'把 Agent 能力吹得太大，结果上线后各种边界问题，又没有人工兜底，项目最终搁浅。教训很简单：不要为了 AI 而 AI；明确场景边界，预留人工干预入口。

进一步学习

• ReAct 论文：Synergizing Reasoning and Acting in Language Models (2023)
• Toolformer - 语言模型自学使用工具 (2023)
• AutoGPT 源码：https://github.com/Significant-Gravitas/AutoGPT
• LangChain 文档：https://python.langchain.com