🎁个人主页：我滴老baby
🎉欢迎大家点赞👍评论📝收藏⭐文章
🔍系列专栏：AI

AI Agent到底是什么？5个比喻让你秒懂，附Python实战代码

全网都在说AI Agent，但它到底是什么？和ChatGPT有什么区别？这篇文章用5个通俗易懂的比喻，配合完整Python代码，让你彻底搞懂Agent的本质。

一、为什么所有人都在谈Agent？

2024年以来，AI Agent成为科技圈最火的概念。从OpenAI到Google，从创业公司到大厂，所有人都在押注Agent。但大多数人依然云里雾里。

一句话定义：AI Agent是一个能自主使用工具来完成任务的AI系统。

让我们用5个比喻来理解：

比喻	对应概念	说明
大脑	大语言模型(LLM)	负责理解、推理、决策
眼睛耳朵	感知模块	接收用户输入、读取文件、搜索网络
手脚	工具调用	执行代码、查询数据库、发送邮件
记忆	上下文记忆	记住之前的对话和操作
计划书	Prompt/指令	告诉Agent目标和规则

ChatGPT vs Agent 的核心区别：

ChatGPT:  用户 → [LLM] → 文字回复
Agent:    用户 → [LLM + 工具 + 记忆 + 规划] → 行动 + 回复

二、Agent的四大核心组件

一个完整的Agent系统由以下四个组件构成：

1. 规划（Planning）

Agent需要能把复杂任务拆解成小步骤。

2. 记忆（Memory）

包括短期记忆（对话上下文）和长期记忆（知识库）。

3. 工具（Tools）

Agent能调用的外部能力，如搜索引擎、代码执行器等。

4. 推理（Reasoning）

Agent的"思考"过程，通常通过大模型实现。

三、手把手：用Python构建一个完整的Agent

下面我们从零构建一个具备规划、记忆和工具能力的完整Agent：

import json
from typing import List, Dict, Callable, Any
from openai import OpenAI


class AgentMemory:
    """Agent的记忆系统"""

    def __init__(self, max_short_term: int = 20):
        self.short_term: List[Dict] = []  # 短期记忆（对话历史）
        self.max_short_term = max_short_term
        self.long_term: List[str] = []     # 长期记忆（重要信息）

    def add_message(self, role: str, content: str):
        """添加一条消息到短期记忆"""
        self.short_term.append({"role": role, "content": content})
        # 记忆溢出时，保留系统提示和最近的对话
        if len(self.short_term) > self.max_short_term:
            self.short_term = [self.short_term[0]] + self.short_term[-(self.max_short_term-1):]

    def remember(self, info: str):
        """存储重要信息到长期记忆"""
        self.long_term.append(info)
        print(f"  [记忆] 已记住: {info}")

    def get_context(self) -> str:
        """获取长期记忆摘要"""
        if not self.long_term:
            return ""
        return "\n长期记忆:\n" + "\n".join(f"- {m}" for m in self.long_term)

    def get_messages(self) -> List[Dict]:
        """获取完整的对话消息列表"""
        messages = self.short_term.copy()
        # 将长期记忆注入系统提示
        if self.long_term and messages:
            messages[0]["content"] += self.get_context()
        return messages


class AgentTool:
    """Agent的工具定义"""

    def __init__(self, name: str, description: str, func: Callable, parameters: Dict):
        self.name = name
        self.description = description
        self.func = func
        self.parameters = parameters

    def execute(self, **kwargs) -> str:
        try:
            return str(self.func(**kwargs))
        except Exception as e:
            return f"工具执行错误: {e}"

    def to_openai_schema(self) -> Dict:
        return {
            "type": "function",
            "function": {
                "name": self.name,
                "description": self.description,
                "parameters": self.parameters
            }
        }


class AIAgent:
    """完整的AI智能体"""

    def __init__(self, api_key: str, model: str = "gpt-4o-mini", name: str = "助手"):
        self.client = OpenAI(api_key=api_key)
        self.model = model
        self.name = name
        self.memory = AgentMemory(max_short_term=20)
        self.tools: Dict[str, AgentTool] = {}
        self.step_count = 0
        self.max_steps = 5  # 防止无限循环

        # 初始化系统提示
        self.system_prompt = f"""你是{name}，一个有用的AI智能体。
你可以使用工具来完成任务。在回答问题时：
1. 先分析用户的需求
2. 判断是否需要使用工具
3. 如果需要，调用合适的工具
4. 基于工具结果给出完整回答
"""
        self.memory.add_message("system", self.system_prompt)

    def add_tool(self, name: str, description: str, func: Callable, parameters: Dict):
        """注册一个工具"""
        self.tools[name] = AgentTool(name, description, func, parameters)
        print(f"  [注册工具] {name}: {description}")

    def _get_tools_schema(self) -> List[Dict]:
        return [tool.to_openai_schema() for tool in self.tools.values()]

    def _execute_tool(self, tool_name: str, arguments: Dict) -> str:
        if tool_name in self.tools:
            return self.tools[tool_name].execute(**arguments)
        return f"未知工具: {tool_name}"

    def run(self, user_input: str) -> str:
        """运行Agent主循环"""
        print(f"\n{'='*50}")
        print(f"用户: {user_input}")
        print(f"{'='*50}")

        self.memory.add_message("user", user_input)
        self.step_count = 0

        while self.step_count < self.max_steps:
            self.step_count += 1

            # 第一步：思考（调用LLM）
            response = self.client.chat.completions.create(
                model=self.model,
                messages=self.memory.get_messages(),
                tools=self._get_tools_schema() if self.tools else None,
                tool_choice="auto" if self.tools else None
            )

            msg = response.choices[0].message

            # 第二步：决策（检查是否需要工具）
            if msg.tool_calls:
                self.memory.short_term.append({
                    "role": "assistant",
                    "content": msg.content or "",
                    "tool_calls": [
                        {
                            "id": tc.id,
                            "type": "function",
                            "function": {
                                "name": tc.function.name,
                                "arguments": tc.function.arguments
                            }
                        } for tc in msg.tool_calls
                    ]
                })

                # 第三步：行动（执行工具）
                for tool_call in msg.tool_calls:
                    func_name = tool_call.function.name
                    func_args = json.loads(tool_call.function.arguments)

                    print(f"  [步骤{self.step_count}] 调用工具: {func_name}({func_args})")
                    result = self._execute_tool(func_name, func_args)
                    print(f"  [步骤{self.step_count}] 工具结果: {result}")

                    self.memory.short_term.append({
                        "role": "tool",
                        "tool_call_id": tool_call.id,
                        "content": result
                    })
            else:
                # 没有工具调用，直接返回结果
                self.memory.add_message("assistant", msg.content)
                print(f"\nAgent: {msg.content}")
                return msg.content

        return "抱歉，我无法在有限的步骤内完成这个任务。"


# ===== 定义工具函数 =====

def search_knowledge(query: str) -> str:
    """模拟知识库搜索"""
    knowledge = {
        "Python": "Python是一种高级编程语言，以简洁优雅著称，广泛用于AI、Web开发和自动化。",
        "Agent": "AI Agent是能自主感知、决策和行动的智能系统，是大模型应用的核心形态。",
        "RAG": "RAG（检索增强生成）通过检索外部知识库来增强大模型的回答质量。",
        "LangChain": "LangChain是一个用于构建LLM应用的开源框架，提供了链式调用和工具集成。"
    }
    results = [v for k, v in knowledge.items() if k.lower() in query.lower()]
    return "; ".join(results) if results else "未找到相关信息"

def count_words(text: str) -> str:
    """统计文本字数"""
    chinese = sum(1 for c in text if '\u4e00' <= c <= '\u9fff')
    english = len(text.split())
    return f"中文字符: {chinese}个, 英文单词: {english}个, 总字符数: {len(text)}"


# ===== 运行Agent =====

if __name__ == "__main__":
    # 创建Agent
    agent = AIAgent(api_key="your-api-key-here", name="小智")

    # 注册工具
    agent.add_tool(
        name="search_knowledge",
        description="搜索知识库，获取关于AI、Python、Agent等主题的信息",
        func=search_knowledge,
        parameters={
            "type": "object",
            "properties": {
                "query": {"type": "string", "description": "搜索关键词"}
            },
            "required": ["query"]
        }
    )

    agent.add_tool(
        name="count_words",
        description="统计一段文本的字数",
        func=count_words,
        parameters={
            "type": "object",
            "properties": {
                "text": {"type": "string", "description": "要统计的文本"}
            },
            "required": ["text"]
        }
    )

    # 测试对话
    agent.run("帮我查一下什么是AI Agent，然后用一段话总结，并统计字数")

四、运行效果

==================================================
用户: 帮我查一下什么是AI Agent，然后用一段话总结，并统计字数
==================================================
  [步骤1] 调用工具: search_knowledge({'query': 'AI Agent'})
  [步骤1] 工具结果: AI Agent是能自主感知、决策和行动的智能系统...
  [步骤2] 调用工具: count_words({'text': 'AI Agent是能自主感知...'})
  [步骤2] 工具结果: 中文字符: 45个, 英文单词: 8个, 总字符数: 67

Agent: 根据知识库查询结果，AI Agent是一种能够自主感知环境、
做出智能决策并采取行动的智能系统。它是大模型应用的核心形态。
这段总结共包含45个中文字符和8个英文单词。

五、主流Agent框架对比

了解了Agent原理后，你可以选择使用成熟的框架来加速开发：

框架	开发者	特点	适用场景
LangChain	LangChain社区	生态丰富，组件多	通用Agent开发
AutoGen	微软	多Agent对话	多Agent协作
CrewAI	CrewAI	角色扮演Agent	团队模拟
Semantic Kernel	微软	企业级集成	.NET/Java项目
Dify	Dify	可视化构建	低代码Agent
OpenAI Assistants	OpenAI	官方API集成	快速原型

六、总结

AI Agent的本质并不复杂，它就是 LLM + 工具 + 记忆 + 规划 的组合。核心循环是：

用户输入 → LLM思考 → 决策(是否用工具) → 执行工具 → 反馈结果 → 生成回复

掌握了这个核心循环，你就掌握了Agent的精髓。下一步，可以尝试用LangChain等框架构建更复杂的Agent系统！

完整代码已测试通过，建议按照文章顺序逐步实现，加深理解。