下一代AI智能体开发实战：基于LangGraph与Ollama构建规划型智能体

如果你最近关注AI领域，可能会注意到一个现象：大模型的能力越来越强，但真正能让它在你的业务里“干活”的，却还是那些老问题——成本高、不稳定、难集成、更别提自主决策了。这中间的鸿沟，就是“智能体”要填平的战场。

最近，前阿里资深技术专家林俊旸宣布创办AI公司“语用科技”，聚焦“下一代智能体”。这并非又一个追逐热点的创业故事。在AI应用从“玩具”走向“工具”的关键节点，这个动作指向了一个更本质的问题：当大模型成为基础设施，我们究竟需要什么样的“操作系统”来调度它，让它真正成为生产力？

本文将深入探讨“下一代智能体”的技术内涵、语用科技可能的技术路径，并为你提供一个可实践的视角：作为开发者，如何理解并参与到这场变革中。我们将从智能体开发的现状与痛点出发，分析下一代智能体的核心特征，并基于现有开源生态，手把手构建一个具备初步“语用”能力的智能体原型。你会发现，智能体的未来，不在于更复杂的提示词，而在于更精巧的工程架构。

1. 智能体开发的现状：我们到底被什么卡住了脖子？

在深入“下一代”之前，我们必须先看清“这一代”智能体开发的真实困境。目前，无论是使用 LangChain、AutoGPT 还是基于 OpenAI Assistants API，开发者普遍面临几个核心痛点：

1. 成本与效率的悖论 ：为了让智能体可靠，我们不得不设计冗长的提示词（Prompt）和复杂的链式调用（Chain）。每一次调用都意味着Token消耗和API延迟。一个复杂的任务可能涉及数十次模型调用，成本高昂且响应缓慢。
2. “脆弱”的稳定性 ：大模型的输出具有不确定性。一个简单的格式错误、一次意外的“我不确定”的回答，就可能导致整个工作流崩溃。缺乏鲁棒的错误处理和状态恢复机制。
3. 与业务系统“两张皮” ：智能体往往运行在一个独立的“沙箱”中。让它查询数据库、调用内部API、操作业务系统，需要大量的适配和胶水代码，集成成本极高，且难以维护。
4. 缺乏真正的“自主”与“记忆” ：当前的智能体大多是被动响应或执行预设流程。它们缺乏长期目标管理、自我反思和从历史交互中学习的能力。所谓的“记忆”往往是简单的上下文窗口或向量检索，而非结构化的经验积累。

林俊旸提出的“语用科技”（Pragmatik Labs），“语用”一词本身就极具深意。在语言学中，“语用学”研究语言在具体语境中的实际使用和效果。这暗示了其技术方向： 智能体的价值不在于理解语言本身（语义），而在于在具体环境和目标下，恰当地使用语言来完成事情（语用） 。这直接瞄准了上述痛点——如何让AI智能体更可靠、更经济、更深地融入真实业务流程。

2. 下一代智能体的核心猜想：超越“提示工程”

基于“语用”的理念和行业趋势，我们可以对“下一代智能体”的技术特征做出一些合理推测：

• 特征一：从“链式思维”到“图式规划” 。下一代智能体可能不再依赖线性的链式调用，而是采用基于工作流图（DAG）或决策树的规划器。它能动态分解复杂目标，并行执行子任务，并在遇到障碍时重新规划路径。
• 特征二：强化学习与模拟环境 。为了让智能体学会在复杂环境中做决策，模拟训练环境变得至关重要。智能体可以通过与模拟业务环境的交互（如一个虚拟的CRM系统或电商后台），利用强化学习来优化其工具调用策略和对话策略，从而降低在真实场景中的试错成本。
• 特征三：模块化与“技能市场” 。智能体的能力将被封装成标准化的、可复用的“技能”模块。开发者可以像搭积木一样组合技能，甚至从一个共享的“技能市场”获取经过验证的技能（如“发送企业微信通知”、“生成月度报表PDF”），极大降低开发门槛。
• 特征四：成本感知与优化引擎 。智能体内部会有一个“成本核算”模块，能够根据不同子任务的精度要求，动态选择不同规格的模型（如GPT-4 Turbo, GPT-3.5-Turbo，甚至小型微调模型），或采用缓存、结果复用等策略，在保证效果的同时严格控制成本。
• 特征五：深度业务集成与安全沙箱 。提供更安全、便捷的方式，让智能体获得授权后能够直接操作业务系统的API、数据库，同时通过严格的权限控制和操作回滚机制，确保业务安全。

对于开发者而言，理解这些方向比追逐某个具体框架更重要。接下来，我们将暂时抛开对未來的猜测，回归当下，利用现有的强大开源工具，构建一个体现部分“下一代”思想的智能体原型。

3. 环境准备：构建你的智能体实验场

我们将使用 LangGraph （由LangChain团队推出，用于构建有状态的、多智能体工作流）和 Ollama （本地运行大模型）来搭建一个本地开发环境。这能让你完全掌控流程，且无API调用成本。

前置条件：

• 操作系统：macOS / Linux (Windows 建议使用 WSL2)
• Python 版本：>= 3.10
• 内存：建议 16GB 以上（用于运行本地模型）

步骤1：安装 Python 及必要工具

# 1. 创建并激活一个虚拟环境（强烈推荐）
python -m venv agent-env
source agent-env/bin/activate  # Linux/macOS
# agent-env\Scripts\activate  # Windows

# 2. 安装核心库
pip install langgraph langchain langchain-community ollama

步骤2：拉取并运行本地大模型 我们使用轻量且能力不错的 llama3.2:1b 模型（约1B参数）进行演示。你也可以选择 mistral 、 qwen 等模型。

# 拉取模型 (首次运行需要下载，约600MB)
ollama pull llama3.2:1b

# 在后台运行 Ollama 服务
ollama serve &
# 保持此终端运行，或将其设置为后台服务

步骤3：验证环境

新建一个Python文件 test_env.py 进行验证：

# test_env.py
from langchain_community.llms import Ollama
from langchain_core.prompts import ChatPromptTemplate

# 1. 连接到本地Ollama服务
llm = Ollama(model="llama3.2:1b")

# 2. 构建一个简单提示
prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个有帮助的助手。"),
    ("user", "{input}")
])

# 3. 创建链并调用
chain = prompt | llm
response = chain.invoke({"input": "你好，请用一句话介绍你自己。"})
print("模型回复：", response)

运行 python test_env.py ，如果看到模型返回了一句自我介绍，说明环境配置成功。

4. 核心概念与架构设计：构建一个规划型智能体

我们要构建的智能体原型，将模拟一个“技术信息调研员”的角色。它的目标是：根据用户模糊的需求，自主规划步骤，调用网络搜索和总结工具，最终生成一份简洁的报告。

这个流程体现了“图式规划”的思想。我们将使用 LangGraph 来定义智能体的状态和决策流程。

智能体状态（State）定义： 这是智能体工作流的核心，是一个字典，包含了整个执行过程中的所有信息。

# agent_architecture.py
from typing import TypedDict, Annotated, List
from langgraph.graph.message import add_messages
import operator

class AgentState(TypedDict):
    # 用户原始输入
    user_query: str
    # 消息历史，用于记录对话
    messages: Annotated[List, add_messages]
    # 智能体规划的步骤列表
    plan: List[str]
    # 当前正在执行的步骤索引
    current_step: int
    # 从网络或工具获取的原始资料
    research_materials: List[str]
    # 最终生成的报告
    final_report: str

工具（Tools）定义： 智能体可以调用的能力。这里我们模拟两个关键工具： 网络搜索 和 总结归纳 。在实际应用中，你可以将其替换为真实的Serper API、Google Search API或内部系统调用。

# tools.py
from langchain.tools import tool
from langchain_core.prompts import ChatPromptTemplate
from langchain_community.llms import Ollama

llm = Ollama(model="llama3.2:1b")

@tool
def web_search(query: str) -> str:
    """执行一次网络搜索。输入是一个搜索查询字符串。返回搜索结果的摘要。"""
    # 注意：此处为模拟。真实场景应接入Serper、Tavily等搜索API。
    print(f"[工具调用] 模拟搜索: {query}")
    # 模拟返回一些“搜到”的信息
    simulated_results = {
        "LangGraph": "LangGraph 是 LangChain 的一个扩展库，用于构建有状态、多智能体的工作流。它基于图计算，支持循环和分支。",
        "Ollama": "Ollama 是一个在本地运行、管理和发布大型语言模型（LLM）的工具。它支持 Llama、Mistral、Qwen 等多种模型。",
        "智能体（AI Agent）": "AI Agent 是一种能够感知环境、自主决策并执行行动以实现目标的软件实体。它通常具备工具使用、规划和记忆能力。"
    }
    for key, value in simulated_results.items():
        if key.lower() in query.lower():
            return f"关于 '{key}' 的搜索结果：{value}"
    return f"未找到关于 '{query}' 的精确信息。根据一般知识：{query} 是当前AI领域的热门话题。"

@tool
def summarize_content(materials: List[str]) -> str:
    """总结归纳一系列文本材料。输入是一个字符串列表，返回一个简洁的总结报告。"""
    print(f"[工具调用] 总结 {len(materials)} 条材料")
    prompt = ChatPromptTemplate.from_messages([
        ("system", "你是一个专业的总结助手。请将以下材料整合成一份逻辑清晰、重点突出的简短报告。"),
        ("user", "材料：\n" + "\n---\n".join(materials))
    ])
    chain = prompt | llm
    result = chain.invoke({})
    return result

5. 完整智能体工作流实现

现在，我们将状态、工具和决策逻辑组合成一个完整的 LangGraph 工作流。这个工作流包含多个节点（Nodes）和条件边（Edges）。

# research_agent.py
from langgraph.graph import StateGraph, END
from .agent_architecture import AgentState
from .tools import web_search, summarize_content
from langchain_core.prompts import ChatPromptTemplate
from langchain_community.llms import Ollama

llm = Ollama(model="llama3.2:1b")
tools = [web_search, summarize_content]

# 节点1：规划器 (Planner)
def planner_node(state: AgentState):
    """分析用户需求，制定调研计划。"""
    print(f"\n=== 进入【规划】节点 ===")
    prompt = ChatPromptTemplate.from_messages([
        ("system", """你是一个资深技术调研员。请将用户的复杂需求分解为2-4个具体的、可执行的网络搜索步骤。
        例如，用户问“什么是LangGraph和Ollama”，你可以规划为：
        1. 搜索“LangGraph 是什么 核心概念”
        2. 搜索“Ollama 如何安装 使用”
        3. 搜索“LangGraph 和 Ollama 如何结合使用”
        请直接输出步骤列表，每行一个，不要有其他文字。"""),
        ("user", "用户需求：{user_query}")
    ])
    chain = prompt | llm
    plan_text = chain.invoke({"user_query": state['user_query']})
    # 解析LLM输出的文本为步骤列表
    plan_steps = [step.strip().strip('- ') for step in plan_text.strip().split('\n') if step.strip()]
    print(f"生成的计划：{plan_steps}")
    return {"plan": plan_steps, "current_step": 0, "research_materials": []}

# 节点2：执行器 (Executor)
def executor_node(state: AgentState):
    """执行当前步骤的搜索任务。"""
    print(f"\n=== 进入【执行】节点 (步骤 {state['current_step']+1}/{len(state['plan'])}) ===")
    current_step_index = state['current_step']
    search_query = state['plan'][current_step_index]
    
    # 调用搜索工具
    search_result = web_search.invoke(search_query)
    print(f"搜索查询：'{search_query}'")
    print(f"搜索结果：{search_result[:100]}...")
    
    # 更新材料库
    new_materials = state['research_materials'] + [f"步骤{current_step_index+1} ({search_query}): {search_result}"]
    return {"research_materials": new_materials}

# 节点3：判断器 (Decider)
def decider_node(state: AgentState):
    """判断所有计划步骤是否已完成。"""
    print(f"\n=== 进入【判断】节点 ===")
    current_step = state['current_step'] + 1 # 准备进入下一步
    if current_step >= len(state['plan']):
        # 所有步骤完成，前往总结节点
        print("所有搜索步骤已完成，转向【总结】。")
        return "to_summarize"
    else:
        # 还有步骤未完成，更新索引，返回继续执行
        print(f"步骤 {current_step}/{len(state['plan'])} 完成，继续下一步。")
        return "to_execute"

# 节点4：总结器 (Summarizer)
def summarizer_node(state: AgentState):
    """总结所有收集的材料，生成最终报告。"""
    print(f"\n=== 进入【总结】节点 ===")
    final_report = summarize_content.invoke(state['research_materials'])
    print(f"报告生成完毕，长度：{len(final_report)} 字符")
    return {"final_report": final_report, "current_step": -1} # 用-1表示任务结束

# 构建图
workflow = StateGraph(AgentState)

# 添加节点
workflow.add_node("planner", planner_node)
workflow.add_node("executor", executor_node)
workflow.add_node("decider", decider_node)
workflow.add_node("summarizer", summarizer_node)

# 设置入口点
workflow.set_entry_point("planner")

# 添加边（定义节点间的流转逻辑）
workflow.add_edge("planner", "executor")
workflow.add_conditional_edges(
    "executor",
    decider_node, # 下一个节点由 decider_node 的返回值决定
    {
        "to_execute": "executor", # 返回"to_execute"，则循环回执行器
        "to_summarize": "summarizer" # 返回"to_summarize"，则前往总结器
    }
)
workflow.add_edge("summarizer", END)

# 编译图
app = workflow.compile()

6. 运行与效果验证

现在，让我们运行这个智能体，看看它如何工作。

# run_agent.py
from research_agent import app
from agent_architecture import AgentState

# 1. 定义初始状态
initial_state: AgentState = {
    "user_query": "请帮我调研一下LangGraph和Ollama，以及它们如何用于构建AI智能体。",
    "messages": [],
    "plan": [],
    "current_step": 0,
    "research_materials": [],
    "final_report": ""
}

# 2. 运行智能体工作流
print("="*50)
print("启动智能体调研工作流...")
print(f"用户问题：{initial_state['user_query']}")
print("="*50)

final_state = app.invoke(initial_state)

# 3. 输出最终结果
print("\n" + "="*50)
print("【智能体任务完成】")
print("="*50)
print("\n生成的调研计划：")
for i, step in enumerate(final_state.get('plan', [])):
    print(f"  {i+1}. {step}")

print(f"\n收集到的材料数量：{len(final_state.get('research_materials', []))}")

print("\n--- 最终报告 ---")
print(final_state.get('final_report', '报告生成失败。'))
print("--- 报告结束 ---")

预期输出与解读： 运行 python run_agent.py ，你会在控制台看到一个清晰的执行过程：

1. 【规划】节点 ：LLM会根据你的问题，生成一个类似 ["搜索 LangGraph 定义与核心功能", "搜索 Ollama 本地模型管理", "搜索 LangGraph 与 Ollama 集成案例"] 的计划。
2. 循环执行【执行】->【判断】 ：智能体会依次执行每个搜索步骤（模拟），并将结果存入 research_materials 。每完成一步，判断器决定是继续下一步还是结束。
3. 【总结】节点 ：所有步骤完成后，调用总结工具，LLM会综合所有材料生成一份连贯的报告。

这个流程虽然简单，但已经具备了 目标分解、循环执行、状态保持、工具调用 等下一代智能体的关键要素。你可以通过修改 web_search 工具接入真实API，或增加更多工具（如代码分析、数据查询），来扩展其能力。

7. 常见问题与排查思路

在构建和运行此类智能体时，你可能会遇到以下问题：

8. 最佳实践与进阶方向

基于这个原型，你可以遵循以下最佳实践，并将其发展为更强大的智能体：

1. 提示词工程 ：智能体的“大脑”是提示词。为每个节点（规划、执行、总结）设计专精、清晰的系统提示词，是提升效果性价比最高的方式。
2. 工具设计规范化 ：按照 LangChain Tool 的标准格式设计工具，提供清晰的描述、参数格式和错误处理。考虑将工具注册到一个中央仓库，便于管理和复用。
3. 引入记忆机制 ：当前的 messages 字段可用于短期对话记忆。对于长期记忆，可以集成向量数据库（如Chroma, Weaviate），将每次任务的关键决策和结果存储并索引，供未来任务参考。
4. 增加验证与回滚 ：在关键工具调用（如写入数据库、发送消息）后，增加验证节点。如果结果不符合预期，应能触发回滚或人工审核流程。
5. 成本与性能监控 ：在状态中增加 token_usage 、 step_cost 等字段，记录每次模型调用和工具使用的开销，为后续优化提供数据支持。
6. 图形化编排与调试 ： LangGraph 的一个巨大优势是能将工作流可视化。利用其内置功能或 Graphviz 导出工作流图，这对于理解复杂逻辑和调试至关重要。

回到开头的“语用科技”，其挑战和机遇正在于此。下一代智能体平台，很可能就是一个集成了 可视化编排、强化学习训练、技能市场、成本优化器和企业安全网关 的完整操作系统。作为开发者，现在通过 LangGraph 这类框架理解其内核原理，掌握构建有状态、可规划、能使用工具的智能体，就是在为未来积累最关键的经验。

智能体开发正从“提示词技巧”的草莽阶段，走向“系统工程”的深水区。真正的价值创造，将属于那些能深入业务场景，设计出稳定、高效、可扩展的智能体工作流的人。