整体架构分层

┌───────────── 外部输入/环境 ─────────────┐
│  用户提问、外部事件、传感器数据          │
└───────────────┬─────────────────────────┘
                ↓
┌─────────────────────────────────────────────────────┐
│                  调度主控引擎（循环核心）             │
│  （控制整体流转、轮次限制、异常拦截、安全校验）       │
└───┬───────────┬───────────┬───────────┬─────────────┘
    ↓           ↓           ↓           ↓
┌───────┐   ┌───────┐   ┌───────┐   ┌───────────────┐
│ 记忆模块 │   │规划模块│   │ LLM大脑 │   │ 工具调用层    │
├───────┤   ├───────┤   ├───────┤   ├───────────────┤
│短期记忆 │   │任务拆解│   │理解推理 │   │搜索/API/代码 │
│长期记忆 │   │步骤编排│   │决策输出 │   │数据库/文件等  │
│工作记忆 │   │反思纠错│   │格式生成 │   │沙箱执行      │
└───────┘   └───────┘   └───────┘   └───────────────┘
                ↑                   ↓
                └───────────────────┘
              （工具结果回传 → 再次思考）

一、标准执行流转（ReAct 经典循环）

感知 → 思考 → 行动 → 观察 → (循环) → 应答结束

1. 感知：接收用户请求 + 加载记忆上下文
2. 思考：LLM 分析任务、规划步骤、判断是否调用工具
3. 行动：框架执行工具调用（LLM 不直接触达外部）
4. 观察：工具返回结果，并入上下文
5. 循环：重复「思考 - 行动 - 观察」，直到任务完成
6. 输出：生成最终自然语言回复，终止循环

二、可运行最小 Python AI Agent 示例

基于模拟工具 + 原生循环实现，无额外框架依赖，Python3.8+ 直接运行，完整还原 Agent 核心逻辑。

# 极简 AI Agent 实现：模拟工具调用 + 经典循环
class SimpleAgent:
    def __init__(self):
        # 短期记忆：对话上下文
        self.messages = []
        # 模拟工具集
        self.tools = {
            "weather": self.get_weather,
            "calculator": self.calculator
        }

    # 模拟LLM：简化版大模型（仅做规则推理，演示用）
    def llm_think(self, prompt):
        """模拟LLM思考，判断调用工具 / 直接回答"""
        prompt = prompt.lower()
        # 规则1：查天气 → 调用weather工具
        if "天气" in prompt:
            return {
                "type": "tool_call",
                "tool_name": "weather",
                "params": {"city": "南京"}
            }
        # 规则2：计算数字 → 调用calculator工具
        elif any(c in prompt for c in "0123456789+-*/"):
            return {
                "type": "tool_call",
                "tool_name": "calculator",
                "params": {"expr": prompt}
            }
        # 规则3：无需工具，直接回答
        else:
            return {
                "type": "answer",
                "content": f"收到你的问题：{prompt}，已直接回复"
            }

    # 工具1：模拟天气查询
    def get_weather(self, city):
        return f"【{city}】今日天气：晴，26℃，微风"

    # 工具2：模拟计算器
    def calculator(self, expr):
        try:
            res = eval(expr)
            return f"计算结果：{expr} = {res}"
        except:
            return "表达式错误，计算失败"

    # 执行工具
    def run_tool(self, tool_name, params):
        func = self.tools.get(tool_name)
        if not func:
            return "工具不存在"
        return func(**params)

    # 主循环：Agent 核心调度
    def run(self, user_input):
        self.messages.append(f"用户：{user_input}")
        current_prompt = "\n".join(self.messages)

        # 循环上限：防止死循环
        max_round = 5
        for _ in range(max_round):
            # 1. 思考
            think_res = self.llm_think(current_prompt)

            if think_res["type"] == "answer":
                # 任务结束，返回答案
                return think_res["content"]
            elif think_res["type"] == "tool_call":
                # 2. 行动：执行工具
                tool_name = think_res["tool_name"]
                params = think_res["params"]
                tool_result = self.run_tool(tool_name, params)
                # 3. 观察：工具结果加入上下文，进入下一轮思考
                self.messages.append(f"工具返回：{tool_result}")
                current_prompt = "\n".join(self.messages)

        return "任务轮次超限，执行终止"


# ========== 测试运行 ==========
if __name__ == "__main__":
    agent = SimpleAgent()

    # 测试1：查天气（调用工具）
    print(agent.run("查询南京今天天气"))
    print("-" * 30)

    # 重置记忆，测试2：计算（调用工具）
    agent.messages = []
    print(agent.run("12 * 8 + 30"))
    print("-" * 30)

    # 重置记忆，测试3：直接问答（不调用工具）
    agent.messages = []
    print(agent.run("你好呀"))

运行结果说明

【南京】今日天气：晴，26℃，微风
------------------------------
计算结果：12 * 8 + 30 = 126
------------------------------
收到你的问题：你好呀，已直接回复

代码核心要点

1. llm_think：模拟 LLM 大脑，做任务判断、决策是否调用工具
2. tools：模拟外部工具（手脚），可扩展为真实 API、数据库、搜索等
3. messages：短期记忆，保存对话 + 工具返回结果
4. 主循环：标准 思考→行动→观察 Agent 闭环，限制最大轮次防死循环

三、扩展说明（落地参考）

1. 生产环境改造方向
   • 把模拟 llm_think 替换为真实大模型接口（OpenAI / 通义 / 千问 / 文心等）
   • 增加向量数据库实现长期记忆、用户知识库
   • 增加规划 / 反思模块：复杂任务自动拆分子步骤
   • 增加安全沙箱：限制代码执行、高危 API 调用
2. 主流框架 快速开发可直接用：LangChain、AutoGPT、AgentGPT、Dify、Coze 等，底层逻辑和上面示例完全一致。