从零构建AI Agent：2026年最实用的开发框架选型与落地实战

2024年我还在用简单的Prompt工程做对话机器人，2025年开始接触LangChain做链式调用，到2026年，AI Agent已经从概念验证走向生产落地。上个月，我帮一家金融科技公司重构了他们的智能研报系统，用Agent架构替代了原来的硬编码流程，原本需要3个分析师花一整天整理的报告，现在Agent 20分钟就能出初稿。这不是什么未来科技，而是当下就能落地的工程实践。

这篇文章，我想把这一年多踩过的坑、验证过的方案，系统性地整理出来。无论你是刚接触Agent的新手，还是已经在做相关项目的工程师，相信都能有所收获。内容涵盖框架选型、核心模式实战、真实项目案例，以及2026年值得关注的技术趋势。

一、什么是AI Agent？

在深入技术细节之前，先厘清一个概念：AI Agent到底是什么？简单来说，AI Agent是一个能够感知环境、进行推理、采取行动的智能系统。它不只是被动回答问题，而是能主动调用工具、执行操作、完成复杂任务。

与传统Chatbot的区别

很多人把Agent和Chatbot混为一谈，其实两者有本质区别：

维度	传统Chatbot	AI Agent
交互模式	单轮/多轮对话	推理-行动循环
工具调用	无或简单API	多工具编排、参数动态生成
记忆能力	会话级上下文	短期+长期+工具记忆
任务完成	信息提供	端到端任务执行
错误处理	简单兜底回复	重试、回退、人工接管

举个例子：用户说"帮我查一下北京明天的天气，如果下雨就提醒我带伞，顺便看看附近有没有好吃的火锅店"。传统Chatbot可能只能回答天气，而Agent会：1）调用天气API获取预报；2）判断是否需要提醒；3）调用地图API搜索火锅店；4）整合结果返回给用户。这就是Agent的核心价值——把多个离散能力串联成完整的任务流。

Agent的三大核心能力

推理（Reasoning）：Agent需要理解用户意图，拆解任务步骤，决定下一步行动。ReAct、CoT、ToT等推理模式都是为此设计的。

记忆（Memory）：Agent需要记住对话历史（短期记忆）、用户偏好和知识（长期记忆）、以及之前调用过哪些工具（工具记忆）。没有记忆的Agent，每次交互都是从头开始，体验极差。

工具使用（Tool Use）：Agent的核心竞争力在于能调用外部工具。无论是查询数据库、调用API、执行代码，还是操作浏览器，工具扩展了Agent的能力边界。

二、主流开发框架对比

2026年的Agent开发框架生态已经相当成熟。我挑选了5个最具代表性的框架，从实际工程角度做对比。以下数据截至2026年6月。

框架	GitHub Stars	成熟度	学习曲线	社区活跃度	企业支持	适合场景
LangChain	90k+	高	中等	极高	LangChain Inc.	通用Agent、复杂工作流
LlamaIndex	40k+	高	中等	高	LlamaIndex Inc.	RAG、知识库Agent
AutoGPT	160k+	中	陡峭	高	社区驱动	自主Agent、研究原型
Dify	30k+	高	平缓	中高	Dify Inc.	低代码、快速搭建
CrewAI	25k+	中	平缓	中	社区驱动	多Agent协作

LangChain：生态最完善的通用框架

LangChain是目前GitHub Stars最多的Agent框架（90k+），生态最完善，文档最齐全。它的核心设计是"链式调用"（Chain）和"代理"（Agent）两种模式。Chain适合固定流程，Agent适合动态决策。

LangChain的优势在于模块化设计，你可以像搭积木一样组合各种组件。缺点是抽象层较多，有时候为了灵活性牺牲了简洁性。我的建议是：如果你需要高度定制化的Agent，LangChain是首选；如果只是做简单应用，可能会觉得它有点重。

LlamaIndex：RAG场景的首选

LlamaIndex（40k+ Stars）最初是为RAG（检索增强生成）设计的，后来逐步扩展为完整的Agent框架。它在知识库索引、向量检索、文档解析方面的能力远超其他框架。

如果你的Agent核心能力是"基于私有知识回答问题"，LlamaIndex比LangChain更合适。它的索引系统支持多种数据结构（列表、树、图），检索策略也更丰富。

Dify：低代码快速落地

Dify（30k+ Stars）是我向非AI专业团队推荐的首选。它提供可视化界面，拖拽式搭建Agent工作流，内置Prompt版本管理、对话日志、运营分析等功能。

某电商平台的技术负责人跟我聊过，他们团队没有专门的AI工程师，用Dify两周就搭出了客服Agent，响应时间从原来的5分钟降到了30秒。这就是低代码平台的价值——降低落地门槛。

AutoGPT：理想很丰满

AutoGPT（160k+ Stars，Stars数最高）是2023年的现象级项目，愿景是打造完全自主的AI Agent。但说实话，目前它更适合做研究原型，而不是生产环境。自主决策的不可控性太高，出错后很难定位问题。

CrewAI：多Agent协作

CrewAI的定位很明确：多Agent协作。你可以定义多个角色（研究员、写手、编辑），让它们分工合作完成任务。适合内容生成、研报撰写等需要多角色配合的场景。

三、ReAct模式实战

ReAct（Reasoning + Acting）是目前最主流的Agent推理模式。它的核心思想是：Agent在每一步都先进行推理（Thought），再决定行动（Action），然后观察结果（Observation），循环往复直到任务完成。

下面是一个完整的天气查询Agent实现，不依赖任何框架，纯Python手写，方便你理解底层原理。

import json
import requests
from typing import Dict, List, Callable

class ReActAgent:
    """ReAct模式Agent：推理+行动循环"""

    def __init__(self, api_key: str, tools: Dict[str, Callable]):
        self.api_key = api_key
        self.tools = tools
        self.memory: List[Dict] = []  # 对话历史
        self.max_steps = 10  # 最大步数，防止死循环

    def think(self, query: str) -> str:
        """调用LLM进行推理"""
        system_prompt = """你是一个智能助手，使用ReAct模式解决问题。
可用工具：{tool_descriptions}

请按以下格式思考：
Thought: [你的推理过程]
Action: [工具名] [参数JSON]
Observation: [等待工具返回]

当任务完成时：
Thought: [总结]
Final Answer: [最终答案]
""".format(tool_descriptions=self._get_tool_descriptions())

        messages = [
            {"role": "system", "content": system_prompt},
            *self.memory,
            {"role": "user", "content": query}
        ]

        response = requests.post(
            "https://api.tokenfind.cn/v1/chat/completions",
            headers={"Authorization": f"Bearer {self.api_key}"},
            json={"model": "gpt-4o", "messages": messages, "temperature": 0.3}
        ).json()

        return response["choices"][0]["message"]["content"]

    def act(self, action_str: str) -> str:
        """解析并执行工具调用"""
        try:
            # 解析 Action: tool_name {"arg": "value"}
            parts = action_str.split(" ", 1)
            tool_name = parts[0].strip()
            args = json.loads(parts[1]) if len(parts) > 1 else {}

            if tool_name not in self.tools:
                return f"错误：未知工具 '{tool_name}'"

            result = self.tools[tool_name](**args)
            return json.dumps(result, ensure_ascii=False)
        except Exception as e:
            return f"执行错误: {str(e)}"

    def run(self, query: str) -> str:
        """主循环：推理->行动->观察"""
        self.memory = [{"role": "user", "content": query}]

        for step in range(self.max_steps):
            # 1. 推理
            thought = self.think(query)
            print(f"[Step {step+1}] {thought}")

            if "Final Answer:" in thought:
                return thought.split("Final Answer:")[1].strip()

            # 2. 解析Action
            if "Action:" not in thought:
                return "无法确定下一步行动"

            action_line = [l for l in thought.split("\n") if "Action:" in l][0]
            action = action_line.replace("Action:", "").strip()

            # 3. 执行工具
            observation = self.act(action)
            print(f"[Observation] {observation}")

            # 4. 记录到记忆
            self.memory.append({"role": "assistant", "content": thought})
            self.memory.append({"role": "user", "content": f"Observation: {observation}"})

        return "达到最大步数限制，任务未完成"

    def _get_tool_descriptions(self) -> str:
        return "\n".join([
            f"- {name}: {func.__doc__}" for name, func in self.tools.items()
        ])


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

def get_weather(city: str, date: str = "today") -> Dict:
    """查询指定城市的天气。参数: city(城市名), date(日期, 默认today)"""
    # 实际项目中调用天气API
    mock_data = {
        "北京": {"today": {"temp": "25°C", "condition": "晴", "rain_prob": 10}},
        "上海": {"today": {"temp": "28°C", "condition": "多云", "rain_prob": 40}},
    }
    return mock_data.get(city, {}).get(date, {"error": "无数据"})

def search_restaurant(city: str, cuisine: str = "") -> Dict:
    """搜索城市内的餐厅。参数: city(城市名), cuisine(菜系, 可选)"""
    return {"city": city, "cuisine": cuisine, "results": ["海底捞", "巴奴毛肚火锅", "凑凑火锅"]}

# ========== 运行Agent ==========
if __name__ == "__main__":
    agent = ReActAgent(
        api_key="your-api-key",
        tools={"get_weather": get_weather, "search_restaurant": search_restaurant}
    )
    result = agent.run("北京今天天气怎么样？如果下雨的话，推荐几家火锅店")
    print(f"\n最终结果: {result}")

这个实现虽然简化了很多工程细节，但核心逻辑是完整的。实际生产环境中，你需要补充：重试机制、超时控制、错误兜底、日志追踪、成本监控等。不过理解这个循环，你就掌握了ReAct的精髓。

四、Tool Use与Function Calling

Tool Use（工具使用）是Agent的核心能力。2026年，主流大模型都原生支持Function Calling，这让工具调用的可靠性大幅提升。下面详细讲解工具定义、参数解析和错误处理。

工具函数定义规范

from typing import Dict, Any, Callable
import inspect

class ToolRegistry:
    """工具注册中心：统一管理Agent可调用的工具"""

    def __init__(self):
        self._tools: Dict[str, Dict] = {}

    def register(self, func: Callable):
        """自动从函数签名生成工具定义"""
        sig = inspect.signature(func)
        params = {
            name: {"type": "string", "description": param.annotation.__name__ if hasattr(param.annotation, '__name__') else "any"}
            for name, param in sig.parameters.items()
            if param.default == inspect.Parameter.empty  # 必填参数
        }

        self._tools[func.__name__] = {
            "function": func,
            "schema": {
                "type": "function",
                "function": {
                    "name": func.__name__,
                    "description": func.__doc__ or "",
                    "parameters": {
                        "type": "object",
                        "properties": params,
                        "required": list(params.keys())
                    }
                }
            }
        }
        return func

    def get_schemas(self) -> List[Dict]:
        """获取所有工具的JSON Schema，用于传给LLM"""
        return [t["schema"] for t in self._tools.values()]

    def execute(self, name: str, arguments: Dict[str, Any]) -> Any:
        """执行指定工具，带错误处理"""
        if name not in self._tools:
            return {"error": f"Tool '{name}' not found"}

        tool = self._tools[name]
        try:
            result = tool["function"](**arguments)
            return {"status": "success", "data": result}
        except TypeError as e:
            return {"error": f"参数错误: {str(e)}"}
        except Exception as e:
            return {"error": f"执行失败: {str(e)}"}


# ========== 使用示例 ==========
registry = ToolRegistry()

@registry.register
def query_database(sql: str, limit: int = 100) -> Dict:
    """执行SQL查询。参数: sql(SQL语句), limit(返回条数上限, 默认100)"""
    # 实际项目中连接数据库执行
    return {"columns": ["id", "name", "amount"], "rows": [[1, "订单A", 1500]]}

@registry.register
def send_email(to: str, subject: str, body: str) -> Dict:
    """发送邮件。参数: to(收件人), subject(主题), body(正文)"""
    return {"message_id": "mock-123", "status": "sent"}

# 传给LLM的工具定义
schemas = registry.get_schemas()
print(json.dumps(schemas, indent=2, ensure_ascii=False))

OpenAI与Claude函数调用对比

特性	OpenAI Function Calling	Claude Tool Use
调用方式	functions参数	tools参数
返回格式	function_call对象	tool_use块
并行调用	支持（一次返回多个）	支持
强制调用	tool_choice参数	tool_choice参数
参数校验	模型端 loosely	模型端 loosely
错误处理	需应用层处理	需应用层处理

两家实现大同小异，核心都是"模型决定调用哪个工具、传什么参数"。应用层需要做严格的参数校验，因为模型生成的参数不一定合法。我的建议是：所有工具调用都要包try-except，必填参数要做空值检查，数值型参数要做范围校验。

五、记忆系统设计

没有记忆的Agent就像金鱼，每次交互都从零开始。一个完整的Agent记忆系统通常分三层：

短期记忆：对话历史

最简单的实现就是维护一个消息列表。但对话长了会超出模型上下文限制，需要截断或摘要。

class ShortTermMemory:
    """短期记忆：管理对话历史，支持滑动窗口和摘要"""

    def __init__(self, max_messages: int = 20, max_tokens: int = 8000):
        self.messages: List[Dict] = []
        self.max_messages = max_messages
        self.max_tokens = max_tokens

    def add(self, role: str, content: str):
        self.messages.append({"role": role, "content": content})
        self._compact()

    def get(self) -> List[Dict]:
        return self.messages.copy()

    def _compact(self):
        """当超出限制时，压缩历史"""
        # 策略1：滑动窗口，保留最近N条
        if len(self.messages) > self.max_messages:
            # 保留system消息和最近N条
            system_msgs = [m for m in self.messages if m["role"] == "system"]
            recent = self.messages[-self.max_messages:]
            self.messages = system_msgs + recent

        # 策略2：当仍超出token限制时，生成摘要（实际生产中使用）
        # summary = self._summarize(self.messages[:half])
        # self.messages = [summary] + self.messages[half:]

长期记忆：向量数据库

长期记忆存储用户画像、知识库、历史偏好等。实现方式是把信息向量化，存入向量数据库，需要时通过语义检索召回。

class LongTermMemory:
    """长期记忆：基于向量数据库的语义检索"""

    def __init__(self, embedding_client, vector_store):
        self.embedder = embedding_client
        self.store = vector_store  # 如ChromaDB、Pinecone、Milvus

    def remember(self, text: str, metadata: Dict = None):
        """存储记忆"""
        vector = self.embedder.embed(text)
        self.store.add(vector, text, metadata or {})

    def recall(self, query: str, top_k: int = 5) -> List[str]:
        """检索相关记忆"""
        query_vector = self.embedder.embed(query)
        results = self.store.search(query_vector, top_k=top_k)
        return [r["text"] for r in results]

    def recall_with_filter(self, query: str, filter_dict: Dict, top_k: int = 5):
        """带过滤条件的检索，比如只查某个用户的记忆"""
        query_vector = self.embedder.embed(query)
        return self.store.search(query_vector, filter=filter_dict, top_k=top_k)

工具记忆：调用记录

工具记忆记录Agent之前调用过哪些工具、传了什么参数、结果是什么。这能避免重复调用，也能在出错时回溯。

class ToolMemory:
    """工具记忆：记录工具调用历史"""

    def __init__(self):
        self.calls: List[Dict] = []

    def record(self, tool_name: str, arguments: Dict, result: Any, duration_ms: int):
        self.calls.append({
            "timestamp": time.time(),
            "tool": tool_name,
            "args": arguments,
            "result": result,
            "duration_ms": duration_ms
        })

    def get_recent(self, n: int = 5) -> List[Dict]:
        return self.calls[-n:]

    def has_called_recently(self, tool_name: str, args: Dict, window: int = 3) -> bool:
        """检查最近N步内是否调用过相同工具+参数"""
        recent = self.calls[-window:]
        for call in recent:
            if call["tool"] == tool_name and call["args"] == args:
                return True
        return False

六、真实案例：智能客服Agent开发全流程

下面分享一个我们团队2026年Q1落地的项目：为某电商平台搭建智能客服Agent。这个项目从需求分析到上线，历时6周。

需求分析

客户的核心痛点：客服团队每天处理3000+咨询，80%是重复问题（订单查询、退换货、物流跟踪），人工响应时间平均5分钟，用户满意度低。

目标：Agent能自动处理70%以上的常见咨询，响应时间控制在30秒内，复杂问题无缝转人工。

架构设计

技术栈选型：

• 框架：Dify（低代码快速搭建）+ LangChain（复杂逻辑定制）
• 模型：DeepSeek-V3（主力，处理中文能力强）+ GPT-4o（复杂推理备用）
• 记忆：Redis（短期）+ Milvus（长期向量记忆）
• 工具：订单查询API、物流跟踪API、退换货系统API、知识库检索

整体架构分三层：

1. 意图识别层：判断用户是查订单、问物流、还是申请售后
2. 任务执行层：调用对应工具获取数据
3. 回复生成层：整合数据，生成自然语言回复

API选型

在API平台选择上，我们评估了多个方案。最终选择了TokenNexus平台作为API接入层，原因是它支持多模型统一调用，可以根据场景自动路由到最优模型，而且国内直连稳定，不用折腾网络问题。对于需要高可靠性的客服场景，这一点很关键。

Prompt工程

客服Agent的Prompt设计有几个关键点：

SYSTEM_PROMPT = """你是某电商平台的智能客服助手。请遵循以下原则：

1. 【身份】你是专业客服，语气亲切但不过度热情
2. 【安全】绝不透露其他用户的订单信息；涉及退款金额必须精确
3. 【边界】无法处理的问题（如投诉、法律纠纷），礼貌转人工
4. 【工具】优先使用工具获取实时数据，不要凭记忆回答
5. 【格式】订单信息用表格展示；物流信息突出预计送达时间

可用工具：
- query_order(user_id, order_id): 查询订单详情
- track_logistics(tracking_no): 跟踪物流状态
- apply_return(order_id, reason): 提交退货申请
- search_kb(query): 搜索知识库

当前时间: {current_time}
用户信息: {user_profile}
"""

测试与上线

测试阶段我们做了三件事：

• 离线测试：准备了500条标注好的测试用例，覆盖各类场景
• A/B测试：先给10%的流量，对比人工和Agent的解决率
• 灰度发布：逐步扩量，监控异常指标

上线效果：Agent处理了78%的咨询，平均响应时间28秒，用户满意度从3.2提升到4.5（5分制）。客服团队从原来的12人缩减到4人，专注处理复杂问题。

七、真实案例：数据分析Agent

第二个案例来自某金融科技公司。他们的分析师每天要花大量时间写SQL、跑数据、做图表。我们用LangChain搭建了一个数据分析Agent，效率提升10倍。

核心能力

Agent的工作流：

1. 理解需求：用户用自然语言描述分析需求
2. 生成SQL：根据数据库Schema生成查询语句
3. 执行查询：连接数据库执行SQL
4. 分析结果：解读数据，发现异常和趋势
5. 生成图表：用Python生成可视化图表
6. 输出报告：整合为Markdown格式的分析报告

class DataAnalysisAgent:
    """数据分析Agent：自然语言 -> SQL -> 可视化 -> 报告"""

    def __init__(self, db_connection, llm_client):
        self.db = db_connection
        self.llm = llm_client
        self.schema = self._load_schema()

    def analyze(self, request: str) -> Dict:
        """主入口"""
        # 1. 生成SQL
        sql = self._generate_sql(request)

        # 2. 执行查询
        df = self._execute_sql(sql)

        # 3. 数据分析
        insights = self._analyze_data(df, request)

        # 4. 生成图表
        chart_path = self._generate_chart(df, request)

        # 5. 生成报告
        report = self._generate_report(request, sql, df, insights, chart_path)

        return {
            "sql": sql,
            "data": df.to_dict(),
            "insights": insights,
            "chart": chart_path,
            "report": report
        }

    def _generate_sql(self, request: str) -> str:
        prompt = f"""根据以下数据库Schema，将用户需求转换为SQL。

Schema:
{self.schema}

用户请求: {request}

要求：
- 只返回SELECT语句，禁止DELETE/UPDATE/DROP
- 使用参数化查询防止SQL注入
- 对金额字段保留2位小数
- 时间范围要明确

SQL:"""
        return self.llm.complete(prompt).strip()

    def _execute_sql(self, sql: str) -> pd.DataFrame:
        # 安全检查
        forbidden = ['delete', 'update', 'drop', 'truncate', 'insert']
        if any(kw in sql.lower() for kw in forbidden):
            raise ValueError("检测到危险操作，已拦截")
        return pd.read_sql(sql, self.db)

    def _analyze_data(self, df: pd.DataFrame, request: str) -> str:
        prompt = f"""分析以下数据，给出关键发现和业务洞察。

数据概览:
{df.describe().to_string()}

前5行数据:
{df.head().to_string()}

用户原始需求: {request}

请用中文输出，包含：
1. 核心指标总结
2. 异常点识别
3. 趋势判断
4.  actionable建议
"""
        return self.llm.complete(prompt)

    def _generate_chart(self, df: pd.DataFrame, request: str) -> str:
        # 根据数据类型自动选择图表
        if 'date' in df.columns or 'time' in df.columns:
            chart_type = 'line'
        elif len(df) <= 10:
            chart_type = 'bar'
        else:
            chart_type = 'scatter'

        # 使用matplotlib生成图表
        plt.figure(figsize=(10, 6))
        # ... 绘图逻辑 ...
        path = f"/tmp/chart_{int(time.time())}.png"
        plt.savefig(path)
        return path

    def _generate_report(self, request, sql, df, insights, chart) -> str:
        return f"""# 数据分析报告

## 分析需求
{request}

## 执行SQL
```sql
{sql}
```

## 数据概览
共 {len(df)} 条记录

## 核心发现
{insights}

## 可视化图表
![图表]({chart})

---
*报告由AI Agent自动生成*
"""

这个Agent上线后，分析师们从"写SQL+做图表+写报告"的重复劳动中解放出来，专注于数据解读和业务策略。原本需要1天的周报，现在Agent 20分钟就能出初稿，分析师再花30分钟审核调整即可。

八、Agent安全与监控

Agent比传统应用更危险，因为它能主动执行操作。安全设计必须从第一天就纳入架构。

输入过滤

用户输入可能包含Prompt Injection攻击。我们的防御策略：

• 指令隔离：用户输入和系统指令用特殊分隔符隔离
• 关键词过滤：拦截"忽略之前指令""system prompt"等攻击模式
• 输入长度限制：防止超长输入消耗资源
• 内容审核：敏感内容先过审核API

输出审核

Agent的输出也要审核，特别是涉及金额、个人信息、法律建议时。我们的做法是：关键信息输出前，走一遍规则校验+模型审核的双保险。

成本监控

Agent的Token消耗可能失控。必须设置：

• 单会话Token上限：超过则强制结束
• 单日预算上限：防止异常流量
• 实时成本告警：超过阈值通知运维

异常告警

监控这些核心指标：

• 工具调用失败率（目标<5%）
• 平均响应时间（目标<3s）
• 用户满意度评分
• 转人工率（过高说明Agent能力不足）
• 循环调用检测（同工具重复调用>3次触发告警）

九、2026年Agent开发趋势

基于这一年的实践和观察，我认为2026年下半年到2027年，Agent开发会有三个明显趋势：

趋势1：多Agent协作成为标配

单Agent的能力有限，多Agent协作能完成更复杂的任务。比如一个研报Agent团队：研究员Agent负责收集数据、分析师Agent负责建模、写手Agent负责撰写、编辑Agent负责审核。CrewAI和AutoGen在这个方向上走得比较远。

趋势2：自主规划能力大幅提升

现在的Agent大多需要人工定义工作流，未来的Agent能自主规划任务步骤。OpenAI的o1系列、Claude 3.5 Opus在推理能力上的突破，让自主规划变得可行。预计2026年底，主流框架都会内置自主规划模块。

趋势3：人机协同模式成熟

完全自主的Agent风险太高，人机协同才是务实路线。Agent负责"做"，人类负责"审"。关键决策点设置人工确认，Agent的每个行动都可追溯、可回滚。这种模式在客服、金融、医疗等对可靠性要求高的领域尤为重要。

结语：Agent不是替代人，而是增强人

写这篇文章的时候，我一直在想一个问题：Agent会不会取代程序员、分析师、客服这些岗位？

我的答案是：不会。至少短期内不会。

Agent的真正价值，不是替代人类，而是把人类从重复、机械的工作中解放出来，让人专注于更有创造性、更需要判断力的工作。那个电商客服项目，Agent处理了78%的咨询，但剩下22%的复杂问题，仍然需要经验丰富的客服来解决。而且因为有了Agent，这4个客服有时间去做用户回访、服务优化，创造更大的价值。

技术永远是工具，人才是目的。Agent开发的核心，不是让机器多智能，而是让人更高效、更有成就感。

希望这篇文章能帮你迈出Agent开发的第一步。有任何问题，欢迎在评论区留言交流。

---

本文基于TokenNexus技术团队2026年6月的实际项目经验。框架版本和功能可能随时变化，建议以各框架官方文档为准。