100行代码搞定LLM Agent？！揭秘AI智能体背后的秘密（附代码）

最新推荐文章于 2025-04-21 16:47:45 发布

python_知世

最新推荐文章于 2025-04-21 16:47:45 发布

阅读量965

点赞数 25

文章标签：人工智能 AI大模型 AI 大模型技术 LLM Agent 代码

本文链接：https://blog.youkuaiyun.com/zhishi0000/article/details/146415714

版权

最近啊，这“LLM Agent”（大语言模型智能体）火得不行，到处都能听到。但好多人一说起这玩意儿，就整一堆专业术语，听得人云里雾里的。

我就纳闷了，这 Agent 真有那么玄乎？不就是个能干活的 AI 助手嘛！今天，我就来扒一扒它的底裤，用大白话给大家讲讲，这 Agent 到底是怎么回事儿。保证大家看完都能明白，甚至还能自己动手写一个！

Agent 到底是个啥？

先别管那些复杂的定义，咱们就用人话来说。LLM Agent，说白了，就是一个更聪明的 ChatGPT。它不仅能跟你聊天，还能帮你干活！

null

想象一下，你有这么一个私人助理：

\1. 它能看懂你的需求：你告诉它“帮我查查下周天气”，它就知道你要干啥。
\2. 它能自己做决定：它会想，“要查天气，得先知道你在哪个城市，然后去查天气预报网站”。
\3. 它能采取行动：它真的会去查天气预报网站，把结果告诉你。
\4. 它能总结经验：如果查不到结果，它会告诉你“没查到”，或者问你“你想查哪个城市的天气？”

这，就是 Agent！它能思考、能决策、能行动，还能从结果中学习，是不是很神奇？

别被忽悠了！Agent 其实很简单！

有些公司啊，为了显得自己牛，故意把 Agent 搞得很复杂。但其实呢，Agent 的核心原理，简单到爆！

Agent = 图（Graph）

没错，就这么简单！任何一个 Agent，都可以用一张图来表示。这张图里有啥呢？

• 节点（Node）：就是一个个的小任务。
• 边（Edge）：就是连接这些小任务的箭头，告诉程序下一步该干啥。
• 循环（Loop）：就是让程序能重复执行某些任务。

就这？没了！

不信？我给你看看几个主流 Agent 框架的代码：

• OpenAI Agents: run.py#L119，这里用图来表示工作流程。
• Pydantic Agents: _agent_graph.py#L779，这里用图来组织各个步骤。
• Langchain: agent_iterator.py#L174，这里展示了循环结构。
• LangGraph: agent.py#L56，这里用了基于图的方法。

你看，这些框架虽然代码很多，但核心思想都是一样的：用图来表示 Agent 的工作流程。

动手写一个 Agent！

说了这么多，咱们来点实际的。我用一个叫 PocketFlow 的小框架，带着大家一步步写一个简单的 Agent。

这 PocketFlow 有啥好呢？它只有 100 行代码！麻雀虽小，五脏俱全。用它来学习 Agent，能让你一眼看穿本质，不会被那些复杂的框架绕晕。

目标：做一个研究助手

咱们要做的这个 Agent，能帮你搜索信息、回答问题。它大概长这样：

• DecideAction：这是“大脑”，负责决定下一步干啥。
• SearchWeb：这是“研究员”，负责搜索网页。
• AnswerQuestion：这是“发言人”，负责把答案告诉你。

第一步：打造“大脑” DecideAction

class DecideAction(Node):
    defprep(self, shared):
        # 从“共享白板”上获取问题和上下文
        context = shared.get("context", "No previous search")
        question = shared["question"]
        return question, context

    defexec(self, inputs):
        question, context = inputs
        # 让 LLM 来决定下一步行动
        prompt = f"""
### CONTEXT
...（省略提示词）...
"""
        response = call_llm(prompt)
        yaml_str = response.split("```yaml")[1].split("```")[0].strip()
        decision = yaml.safe_load(yaml_str)
        return decision

    defpost(self, shared, prep_res, exec_res):
        # 如果决定搜索，就把搜索词记在“共享白板”上
        if exec_res["action"] == "search":
            shared["search_query"] = exec_res["search_query"]
        # 告诉程序下一步该执行哪个节点
        return exec_res["action"]shared["search_query"] = exec_res["search_query"]        # 告诉程序下一步该执行哪个节点        return exec_res["action"]

• prep：准备阶段，看看之前有没有搜索过，把问题和上下文都准备好。
• exec：执行阶段，让 LLM 来决定是搜索还是回答。这里用了一个提示词（prompt），告诉 LLM 现在的任务和可选的行动。
• post：收尾阶段，如果 LLM 决定搜索，就把搜索词记下来，然后告诉程序下一步该干啥。

第二步：打造“研究员” SearchWeb

class SearchWeb(Node):
    defprep(self, shared):
        # 获取搜索词
        return shared["search_query"]

    defexec(self, search_query):
        # 调用 Google 搜索 API （这里需要你自己去申请 API key）
        search_client = GoogleSearchAPI(api_key="GOOGLE_API_KEY")
        search_params = {
            "query": search_query,
            "num_results": 3,
        }
        results = search_client.search(search_params)
        # 格式化搜索结果
        formatted_results = f"Results for: {search_query}\n"
        for result in results:
            formatted_results += f"- {result.title}: {result.snippet}\n"
        return formatted_results

    defpost(self, shared, prep_res, exec_res):
        # 把搜索结果存到“共享白板”上
        previous = shared.get("context", "")
        shared["context"] = previous + "\n\nSEARCH: " + shared["search_query"] + "\nRESULTS: " + exec_res
        # 搜索完，回到“大脑”
        return "decide"

• prep：准备阶段，拿到搜索词。
• exec：执行阶段，调用 Google 搜索 API，把结果整理好。
• post：收尾阶段，把搜索结果存起来，然后告诉程序下一步该执行 DecideAction。

注意： 这里的 GoogleSearchAPI 需要你自己实现，或者用现成的库。你得去 Google Cloud 申请 API key 才能用。

第三步：打造“发言人” AnswerQuestion

class AnswerQuestion(Node):
    defprep(self, shared):
        # 获取问题和所有搜索结果
        return shared["question"], shared.get("context", "")

    defexec(self, inputs):
        question, context = inputs
        # 让 LLM 根据搜索结果回答问题
        prompt = f"""
### CONTEXT
...（省略提示词）...
"""
        return call_llm(prompt)

    defpost(self, shared, prep_res, exec_res):
        # 把答案存到“共享白板”上
        shared["answer"] = exec_res
        # 任务完成！
        return "done"

• prep：准备阶段，拿到问题和所有搜索结果。
• exec：执行阶段，让 LLM 用一个提示词来生成答案。
• post：收尾阶段，把答案存起来，然后告诉程序任务结束。

第四步：把它们串起来！

# 创建节点实例
decide = DecideAction()
search = SearchWeb()
answer = AnswerQuestion()

# 连接节点
decide - "search" >> search
decide - "answer" >> answer
search - "decide" >> decide

# 创建流程
flow = Flow(start=decide)

这段代码，就是把我们刚才写的三个节点，按照预定的流程连接起来。

跑起来看看！

# 提个问题
shared = {"question": "法国的首都是哪里？"}

# 启动流程！
flow.run(shared)

# 看看答案
print(shared["answer"])运行结果：

运行结果：

The capital of France is Paris, which is also known as the City of 
Light.

整个流程走一遍

\1. 用户提问：“法国的首都是哪里？”
\2. DecideAction：“我不知道啊，得查一下。” （决定搜索“法国首都”）
\3. SearchWeb：“我查到了！法国首都是巴黎。” （把搜索结果存起来）
\4. DecideAction：“嗯，现在我知道了，可以回答了。”
\5. AnswerQuestion：“法国的首都是巴黎，它也被称为光之城。”

回顾下

你看，Agent 其实没那么复杂吧？它就是几个节点连起来，按照一定的流程执行任务。

下次你再看到那些复杂的 Agent 框架，别慌！想想老码小张今天讲的，找找里面的节点和连接，看看它们是怎么串起来的。

掌握了这个核心原理，你就能看懂任何 Agent 系统，甚至能自己动手写一个！

课后思考

\1. PocketFlow 只有 100 行代码，功能比较简单。如果你想做一个更强大的 Agent，你觉得可以怎么改进它？
\2. 除了搜索，Agent 还能干很多别的事情。你能想出一些其他的应用场景吗？
\3. 对比一下 LangChain、LangGraph 和 OpenAI Function Calling，它们各自有什么优缺点？

特性	LangChain	LangGraph	OpenAI Function Calling	PocketFlow
定位	功能全面的 LLM 应用框架	专注于构建具有循环和状态的 Agent	允许 LLM 模型调用开发者定义的函数	极简的 LLM Agent 框架，用于学习和原型验证
核心概念	Chains, Agents, Tools, Memory	Nodes, Edges, StateGraph	Functions, Parameters, Responses	Nodes, Flow, Shared Store
优点	功能丰富，社区活跃，支持多种 LLM 和工具	易于理解和调试，适合构建复杂的 Agent 工作流	与 OpenAI 模型紧密集成，简化函数调用流程	简单易学，代码量少，易于理解 Agent 原理
缺点	学习曲线陡峭，抽象层级较高，可能难以调试	相对较新，生态系统不如 LangChain 完善	仅限于 OpenAI 模型，不够灵活	功能有限，不适合生产环境
适用场景	需要快速构建各种 LLM 应用的场景	需要构建具有复杂状态和循环逻辑的 Agent	需要让 OpenAI 模型与外部 API 交互的场景	学习 Agent 原理，快速验证想法
代码示例	`from langchain import ...`	`from langgraph import ...`	`response = openai.ChatCompletion.create(..., functions=...)`	`from pocketflow import ...`