引言

在构建多智能体协作系统时，你是否陷入过这样的困境？

• 上下文爆炸：5 轮对话后，消息历史突破 5000 tokens，每次调用成本翻倍
• 状态传递混乱：需求分析的结果要传给测试点设计，只能塞在消息里，容易丢失
• 提示词注入低效：想让智能体看到之前步骤的输出，手动拼接提示词，维护成本高

这些问题本质上都指向一个核心：上下文工程（Context Engineering）。

为此，我基于 LangGraph 1.0 中间件进行了深度二次封装，设计了 middlewareV1 工具库。通过分层架构、工厂模式、智能过滤算法、状态同步机制、动态提示词注入五大核心设计，彻底解决了上下文工程难题。

本文将深度剖析这套二次封装的设计原理、核心机制、算法实现，带你领略如何优雅地解决 AI 智能体的上下文工程问题。

项目实战：

一、middlewareV1 的二次封装核心原理深度解析

1.1 分层架构：通用层 + 配置层的解耦设计

设计理念：将通用能力和业务配置彻底分离

middlewareV1 架构┌────────────────────────────────────────────────────┐│  业务配置层 (middleware_config.py)                 ││  ├─ FilterConfig 配置（各智能体的过滤策略）         ││  ├─ ContextConfig 配置（提示词注入字段映射）        ││  └─ 便捷工厂函数（create_xxx_hooks）                │└────────────────┬───────────────────────────────────┘                 │ 依赖┌────────────────┴───────────────────────────────────┐│  通用工具层 (middlewareV1/)                         ││  ├─ ContextManagerFactory（中间件工厂）            ││  ├─ MessageFilter（消息过滤器）                     ││  ├─ StateSynchronizer（状态同步器）                ││  ├─ StateUpdateBuilder（状态更新构建器）            ││  └─ 工具函数（消息处理、类型判断等）                │└────────────────────────────────────────────────────┘

核心优势：

• 通用层：提供可复用的基础能力，零业务依赖
• 配置层：针对具体业务定制策略，修改只需改配置
• 高内聚低耦合：通用层稳定不变，业务层灵活扩展

1.2 ContextManagerFactory：工厂模式 + 动态函数生成

核心设计 1：工厂模式统一创建中间件

# context_manager.py:52class ContextManagerFactory:    """中间件工厂类 - 统一创建标准化的钩子函数"""    @staticmethod    def create_before_model_hook(        strategy: MessageFilterStrategy,        phase_name: str,        state_fields_to_init: Optional[Dict[str, Any]] = None,        custom_logic: Optional[CustomLogicFunc] = None,        verbose: bool = True    ):        """创建 before_model 钩子"""

设计精髓：

• 工厂方法模式：将钩子创建逻辑封装，调用者无需关心内部实现
• 参数化配置：通过参数控制行为，而不是写死在代码里
• 高度可扩展：支持自定义逻辑注入（custom_logic 参数）

核心设计 2：动态函数生成避免中间件去重失效

关键问题：LangGraph 会对中间件进行去重检测，如果多个智能体使用同一个钩子函数，会被误判为重复

解决方案：动态生成唯一函数名

# context_manager.py:74def create_before_model_hook(strategy, phase_name, ...):    # 🔑 关键创新：动态生成函数名    func_name = f"before_model_{phase_name}_hook"    # 构建函数定义代码    func_code = f"""def {func_name}(state, runtime):    return _hook_impl(state, runtime)"""    # 定义实际的钩子实现逻辑    def _hook_impl(state, runtime):        # ... 实际逻辑        pass    # 🔑 使用 exec 在局部命名空间中动态创建函数    local_namespace = {'_hook_impl': _hook_impl}    exec(func_code, local_namespace)    hook_func = local_namespace[func_name]    # 返回装饰后的钩子    return before_model(hook_func)

技术亮点：

• 元编程技术：使用 exec 动态生成函数，每个智能体的钩子函数名都不同
• 闭包封装：_hook_impl 捕获外部变量，保持配置隔离
• 去重规避：before_model_requirement_analysis_hook ≠ before_model_test_point_design_hook

1.3 MessageFilter：智能消息过滤算法

核心原理：按类型反向保留最新 N 条

算法思路：

# message_filters.py:82class MessageFilter:    @staticmethod    def filter_messages(messages, strategy, verbose=True):        """根据策略过滤消息"""        config = strategy.value  # 获取 FilterConfig        filtered = []        # 1. 保留 HumanMessage（从后往前取最新的 N 条）        if config.human > 0:            human_msgs = filter_messages_by_type(                messages, MessageType.HUMAN, config.human            )            filtered.extend(human_msgs)        # 2. 保留 ToolMessage        if config.tool > 0:            tool_msgs = filter_messages_by_type(                messages, MessageType.TOOL, config.tool            )            filtered.extend(tool_msgs)        # 3. 保留 AIMessage        if config.ai > 0:            ai_msgs = filter_messages_by_type(                messages, MessageType.AI, config.ai            )            filtered.extend(ai_msgs)        return filtered

核心函数：filter_messages_by_type（utils.py:89）

def filter_messages_by_type(    messages: List[BaseMessage],    msg_type: MessageType,    count: int,    require_content: bool = True) -> List[BaseMessage]:    """按类型过滤消息，保留最新的 N 条"""    if count <= 0:        return []    filtered = []    # 🔑 关键：从后往前遍历，保证拿到最新的消息    for msg in reversed(messages):        if is_message_type(msg, msg_type):            if require_content andnot has_content(msg):                continue# 跳过空消息            filtered.insert(0, msg)  # 插入到开头，保持原始顺序            if len(filtered) >= count:                break    return filtered

算法优势：

• **时间复杂度 O(n)**：单次遍历，高效
• 保持原始顺序：虽然反向遍历，但用 insert(0) 保持消息的时间顺序
• 智能跳过空消息：避免无效消息占用配额

配置化策略：一行代码定义过滤规则

# middleware_config.py:46class TestCaseAgentFilterConfig:    # 需求分析专家：需要工具消息（需求文档内容）    REQUIREMENTS_ANALYST = FilterConfig(        human=3, ai=1, tool=1, system=0,        description="需求分析专家策略"    )    # 测试点设计专家：不需要工具消息（数据从 state 获取）    TEST_POINT_DESIGNER = FilterConfig(        human=3, ai=1, tool=0, system=0,        description="测试点设计专家策略"    )    # 评审专家：需要更多 AI 消息（了解完整流程）    TEST_CASE_REVIEWER = FilterConfig(        human=3, ai=3, tool=0, system=0,        description="评审专家策略: 保留更多 AI 输出用于全面评审"    )

效果对比：

原始消息历史 (15 条):  HumanMessage("需求分析")  AIMessage("分析结果...")  ToolMessage("需求文档内容...")  HumanMessage("测试点设计")  AIMessage("测试点...")  HumanMessage("编写用例")  AIMessage("测试用例...")  HumanMessage("继续优化")  AIMessage("优化后的用例...")  ... (共 15 条)↓ 应用 TEST_CASE_REVIEWER 策略 (human=3, ai=3)过滤后 (6 条):  HumanMessage("编写用例")  HumanMessage("继续优化")  HumanMessage(最新的消息)  AIMessage("测试用例...")  AIMessage("优化后的用例...")  AIMessage(最新的 AI 输出)📊 过滤结果: 15 → 6 (节省 60% token)

一直在更新，更多的大模型学习和面试资料已经上传带到CSDN的官方了，有需要的朋友可以扫描下方二维码免费领取【保证100%免费】👇👇

1.4 StateSynchronizer：状态同步机制

核心原理：自动提取 AI 输出并保存到 state 字段

问题场景：

• 需求分析智能体输出分析结果，如何传递给测试点设计智能体？
• 传统方式：塞在消息里，后续智能体遍历消息历史提取（低效且脆弱）

middlewareV1 方案：通过 after_model 钩子自动同步

# state_sync.py:32class StateSynchronizer:    @staticmethod    def save_ai_output_to_state(        state: Dict[str, Any],        field_name: str,        messages: List[BaseMessage],        verbose: bool = True    ) -> Optional[str]:        """从消息历史中提取最新的 AI 输出，保存到指定 state 字段"""        # 从后往前查找最新的 AIMessage        content = extract_latest_ai_message(messages)        if content:            if verbose:                print(f"💾 保存 AI 输出到 state.{field_name} ({len(content)} 字符)")            return content        return None

工作流程：

1. AI 模型调用完成，输出保存在 messages 中   messages = [..., AIMessage("需求分析结果...")]2. after_model 钩子自动执行   @after_model   def save_result(state, runtime):       content = StateSynchronizer.save_ai_output_to_state(           state, "requirement_analysis", state['messages']       )       return {"requirement_analysis": content}3. 状态更新   state["requirement_analysis"] = "需求分析结果..."4. 后续智能体直接从 state 读取   requirement = state["requirement_analysis"]  # 无需遍历消息

核心优势：

• 自动化：无需手动遍历消息历史
• 类型安全：使用 isinstance(msg, AIMessage) 精确识别
• 可追溯：状态字段命名清晰，易于调试

1.5 StateUpdateBuilder：构建器模式优雅更新状态

核心原理：链式调用构建状态更新字典

问题场景：before_model 和 after_model 钩子需要返回一个状态更新字典，手动拼接容易出错

middlewareV1 方案：使用构建器模式

# state_sync.py:305class StateUpdateBuilder:    """状态更新构建器 - 用于构建 state 更新字典"""    def __init__(self):        self.updates: Dict[str, Any] = {}    def add_field(self, field_name: str, value: Any):        """添加字段更新"""        if value isnotNone:            self.updates[field_name] = value        return self  # 返回 self 支持链式调用    def add_fields(self, fields: Dict[str, Any]):        """批量添加字段更新"""        for field_name, value in fields.items():            self.add_field(field_name, value)        return self    def add_if_not_exists(self, state, field_name, value):        """只在字段不存在时添加"""        ifnot state.get(field_name):            self.add_field(field_name, value)        return self    def build(self) -> Optional[Dict[str, Any]]:        """构建最终的更新字典"""        return self.updates if self.updates elseNone

使用示例：

# context_manager.py:100def _hook_impl(state, runtime):    # 创建构建器    builder = StateUpdateBuilder()    # 1️⃣ 消息过滤    filtered_messages = MessageFilter.filter_messages(messages, strategy)    if len(filtered_messages) != len(messages):        builder.add_field("messages", filtered_messages)    # 2️⃣ 更新阶段状态    new_phase = StateInitializer.init_phase_field(state, phase_name)    if new_phase:        builder.add_field("current_phase", new_phase)        new_count = StateInitializer.init_iteration_counter(state)        builder.add_field("iteration_count", new_count)    # 3️⃣ 初始化时间戳（只在不存在时添加）    timestamp = StateInitializer.init_timestamp_field(state, 'start_time')    builder.add_if_not_exists(state, 'start_time', timestamp)    # 4️⃣ 构建最终更新    return builder.build()  # {"messages": [...], "current_phase": "...", ...}

核心优势：

• 链式调用：代码更流畅，可读性强
• 自动过滤 None：只有非空值才会被添加
• 条件添加：add_if_not_exists 避免覆盖已有数据

1.6 动态提示词注入机制

核心原理：在模型调用前动态拼接上下文到提示词

工作流程：

1. 定义基础提示词   base_prompt = "你是测试点设计专家..."2. 配置需要注入的字段   context_fields = {       "requirement_doc": "📄 需求文档内容",       "test_points": "🎯 测试点清单"   }3. dynamic_prompt 钩子自动注入   @dynamic_prompt   def hook(request):       prompt = base_prompt       for field, title in context_fields.items():           value = state[field]           if value:               prompt += f"\n\n# {title}\n```\n{value}\n```\n"       return prompt4. 最终提示词   "你是测试点设计专家...   # 📄 需求文档内容

用户登录功能…

# 🎯 测试点清单

1. 正常登录测试
2. 密码错误测试 …

实现代码：

# context_manager.py:391

@staticmethod

def create_dynamic_prompt_hook(
    base_prompt: str,
    context_fields: Dict[str, str],  # {state字段: 显示标题}
    execution_guide: Optional[str] = None,
    verbose: bool = False
):

    @dynamic_prompt

def hook(request: ModelRequest):

        state = request.state

        prompt = base_prompt

# 注入上下文字段

for
 state_field, title 
in
 context_fields.items():

            field_value = state.get(state_field)

if
 field_value:

                context_block = 
f"\n\n# {title}\n```\n{field_value}\n```\n"

                prompt += context_block

# 添加执行指引

if
 execution_guide:

            prompt += 
f"\n{execution_guide}"

return
 prompt

# 设置唯一名称避免去重

    hook.__name__ = 
f"dynamic_prompt_{list(context_fields.keys())[0]}"

return
 hook

核心优势：

• 自动化注入：无需手动拼接字符串
• 统一格式：使用 Markdown 代码块，可读性好
• 灵活配置：只需定义 context_fields 映射
• 支持执行指引：可以添加额外的任务说明

二、如何解决上下文工程三大问题

2.1 问题 1：上下文爆炸 → 智能消息过滤

解决方案：使用 before_model 钩子 + 配置化过滤策略

效果对比：

场景	原始消息数	过滤后消息数	Token 节省	成本降低
需求分析	12 条	5 条	58%	58%
测试点设计	18 条	4 条	78%	78%
用例编写	25 条	5 条	80%	80%
用例评审	30 条	6 条	80%	80%

实现代码：

# middleware_config.py:498def create_test_case_reviewer_hooks(base_prompt, verbose=True):    # 使用预定义的过滤策略    before_hook = ContextManagerFactory.create_before_model_hook(        strategy=TestCaseAgentFilterConfig.TEST_CASE_REVIEWER,  # human=3, ai=3        phase_name="test_case_review",        verbose=verbose    )    return before_hook

2.2 问题 2：状态传递混乱 → 结构化状态同步

解决方案：使用 after_model 钩子 + StateSynchronizer

数据流：

需求分析智能体   ↓ (AI 输出)   AIMessage("需求分析结果...")   ↓ (after_model 钩子)   state["requirement_analysis"] = "需求分析结果..."   state["requirement_doc"] = "需求文档内容..."  # 从工具消息提取   ↓测试点设计智能体   ← 从 state 读取数据（无需遍历消息）   requirement = state["requirement_analysis"]   doc = state["requirement_doc"]

实现代码：

# middleware_config.py:285def create_requirements_analyst_hooks(base_prompt, verbose=True):    after_hook = ContextManagerFactory.create_after_model_hook(        phase_name="analysis",        state_field_to_save="requirement_analysis",  # 保存 AI 输出        custom_logic=requirements_analyst_after_logic,  # 保存需求文档        verbose=verbose    )    return after_hook# 自定义逻辑：从工具消息中提取需求文档def requirements_analyst_after_logic(state, runtime):    for msg in reversed(state['messages']):        if isinstance(msg, ToolMessage) and msg.name == 'analyze_requirements_from_input':            return {"requirement_doc": msg.content}    returnNone

2.3 问题 3：提示词注入低效 → 动态上下文注入

解决方案：使用 dynamic_prompt 钩子 + 配置化字段映射

实现代码：

# middleware_config.py:572def create_test_case_reviewer_hooks(base_prompt, verbose=True):    dynamic_hook = ContextManagerFactory.create_dynamic_prompt_hook(        base_prompt=base_prompt,        context_fields={            "requirement_doc": "📄 需求文档内容",            "test_points": "🎯 测试点清单",            "test_cases": "📝 测试用例"        },        execution_guide="""🔥 执行要求:1. 仔细阅读需求文档、测试点和测试用例2. 按照审核标准逐一检查测试用例质量3. 给出明确的审核意见和改进建议4. 完成后输出"测试用例评审完成"或"需要重新设计"        """,        verbose=verbose    )    return dynamic_hook

执行日志：

🟡 dynamic_prompt: 注入上下文  ✅ 注入 📄 需求文档内容: 1523 字符  ✅ 注入 🎯 测试点清单: 856 字符  ✅ 注入 📝 测试用例: 2341 字符📏 最终提示词长度: 5234 字符

三、实战案例：测试用例评审智能体的完整实现

3.1 业务场景

测试用例评审智能体需要：

1. 读取需求文档、测试点、测试用例（来自之前步骤）
2. 进行质量评审，给出反馈
3. 保存评审结果，供后续智能体使用

3.2 使用 middlewareV1 的完整实现

Step 1：定义过滤策略（middleware_config.py:76）

class TestCaseAgentFilterConfig:    TEST_CASE_REVIEWER = FilterConfig(        human=3, ai=3, tool=0, system=0,        description="评审专家策略: 保留更多 AI 输出用于全面评审"    )

Step 2：创建中间件钩子（middleware_config.py:498）

def create_test_case_reviewer_hooks(base_prompt, verbose=True):    # 1. dynamic_prompt：注入上下文    dynamic_hook = ContextManagerFactory.create_dynamic_prompt_hook(        base_prompt=base_prompt,        context_fields={            "requirement_doc": "📄 需求文档内容",            "test_points": "🎯 测试点清单",            "test_cases": "📝 测试用例"        },        verbose=verbose    )    # 2. before_hook：消息过滤    before_hook = ContextManagerFactory.create_before_model_hook(        strategy=TestCaseAgentFilterConfig.TEST_CASE_REVIEWER,        phase_name="test_case_review",        verbose=verbose    )    # 3. after_hook：保存评审反馈    after_hook = ContextManagerFactory.create_after_model_hook(        phase_name="test_case_review",        state_field_to_save="review_feedback",        verbose=verbose    )    return dynamic_hook, before_hook, after_hook

Step 3：应用到智能体（test_case_reviewer_agent.py:69）

# 初始化中间件dynamic_hook, before_hook, after_hook = create_test_case_reviewer_hooks(    base_prompt=TEST_CASE_REVIEWER_PROMPT,    verbose=True)# 创建智能体test_case_reviewer_agent = create_agent(    model=model,    tools=[],    system_prompt=TEST_CASE_REVIEWER_PROMPT,    name="test_case_reviewer",    state_schema=TestCaseState,    middleware=[        get_dynamic_model_middleware(),        dynamic_hook,   # 动态提示词注入        before_hook,    # 消息过滤        after_hook      # 结果保存    ])

3.3 执行流程可视化

┌─────────────────────────────────────────────────────────────┐│  1. before_model 中间件执行                                 │├─────────────────────────────────────────────────────────────┤│  🔍 消息过滤: 评审专家策略                                  ││  📊 过滤结果: 15 → 6 (HM:3, AI:3, TM:0, SYS:0)             ││  💾 更新 2 个字段                                           │└─────────────────────────────────────────────────────────────┘                          ↓┌─────────────────────────────────────────────────────────────┐│  2. dynamic_prompt 中间件执行                               │├─────────────────────────────────────────────────────────────┤│  提示词注入：                                               ││  ✅ 注入 📄 需求文档内容: 1523 字符                         ││  ✅ 注入 🎯 测试点清单: 856 字符                            ││  ✅ 注入 📝 测试用例: 2341 字符                             ││  📏 最终提示词长度: 5234 字符                               │└─────────────────────────────────────────────────────────────┘                          ↓┌─────────────────────────────────────────────────────────────┐│  3. LLM 模型调用                                            │├─────────────────────────────────────────────────────────────┤│  [AI 进行评审分析...]                                       ││  "评审意见：测试用例整体质量良好，但以下几点需要改进..."  │└─────────────────────────────────────────────────────────────┘                          ↓┌─────────────────────────────────────────────────────────────┐│  4. after_model 中间件执行                                  │├─────────────────────────────────────────────────────────────┤│  💾 保存 AI 输出到 state.review_feedback (687 字符)         ││  ✅ 阶段完成: test_case_review_completed                    ││  💾 保存 2 个字段到 state                                   │└─────────────────────────────────────────────────────────────┘

---

四、多智能体协作：test_case_agentV5 完整工作流

在 test_case_agentV5.py 中，使用 Supervisor 模式协调 5 个子智能体，每个都使用了 middlewareV1：

┌──────────────┐                      │  Supervisor  │                      │ (pre_model)  │  ← 使用 SUPERVISOR 策略                      └──────┬───────┘                             │          ┌──────────────────┼──────────────────┬──────────────┐          ↓                  ↓                  ↓              ↓    ┌─────────┐        ┌─────────┐       ┌─────────┐   ┌─────────┐    │需求分析 │   →    │测试点   │  →    │用例编写 │→  │用例评审 │    └─────────┘        │设计     │       └─────────┘   └─────────┘         ↓              └─────────┘             ↓              ↓    middleware             ↓                middleware     middleware    - before_hook      middleware          - dynamic      - dynamic    - after_hook       - dynamic           - before       - before                       - before            - after        - after                       - after                                                               ↓                                                          ┌─────────┐                                                          │工具智能体│                                                          └─────────┘

各智能体的中间件配置：

智能体	过滤策略 (H/A/T/S)	dynamic_prompt 注入	保存到 state
需求分析	3/1/1/0	-	requirement_analysis requirement_doc
测试点设计	3/1/0/0	requirement_doc	test_points
用例编写	3/2/0/0	requirement_doc test_points	test_cases
用例评审	3/3/0/0	requirement_doc test_points test_cases	review_feedback
工具智能体	3/2/0/0	test_cases	extracted_json

五、最佳实践

✅ 推荐做法

1. 为每个智能体定制过滤策略

class MyAgentFilterConfig:    # 需要工具消息的智能体    AGENT_WITH_TOOLS = FilterConfig(human=3, ai=1, tool=1, system=0)    # 只需要对话历史的智能体    AGENT_DIALOGUE = FilterConfig(human=3, ai=2, tool=0, system=0)    # 需要全流程上下文的智能体    AGENT_REVIEW = FilterConfig(human=5, ai=5, tool=0, system=1)

2. 使用工厂函数创建中间件

def create_my_agent_hooks(base_prompt, verbose=True):    dynamic_hook = ContextManagerFactory.create_dynamic_prompt_hook(...)    before_hook = ContextManagerFactory.create_before_model_hook(...)    after_hook = ContextManagerFactory.create_after_model_hook(...)    return dynamic_hook, before_hook, after_hook

3. 利用 dynamic_prompt 注入上下文，而不是塞在消息里

# ❌ 不要这样做messages.append(HumanMessage(    content=f"需求文档：{long_document}\n测试点：{long_test_points}..."))# ✅ 应该这样做state["requirement_doc"] = long_documentstate["test_points"] = long_test_points# dynamic_prompt 自动注入dynamic_hook = ContextManagerFactory.create_dynamic_prompt_hook(    base_prompt=PROMPT,    context_fields={        "requirement_doc": "📄 需求文档内容",        "test_points": "🎯 测试点清单"    })

❌ 避免的错误

1. 不要在每个智能体重复写过滤逻辑

# ❌ 不要这样做@before_modeldef hook1(state, runtime):    messages = state['messages']    filtered = []    for msg in reversed(messages):        if isinstance(msg, HumanMessage):            filtered.insert(0, msg)    return {"messages": filtered}# ✅ 应该使用工厂方法before_hook = ContextManagerFactory.create_before_model_hook(    strategy=FilterConfig(human=3, ai=1),    phase_name="my_phase")

2. 不要手动遍历消息提取 AI 输出

# ❌ 不要这样做for msg in reversed(state['messages']):    if isinstance(msg, AIMessage):        result = msg.content        break# ✅ 使用 StateSynchronizerresult = StateSynchronizer.save_ai_output_to_state(    state, "result_field", state['messages'])

基于 LangGraph 1.0 中间件的二次封装 middlewareV1，通过分层架构、工厂模式、智能过滤、状态同步、动态注入五大核心机制，彻底解决了 AI 智能体的上下文工程难题。

六、如何学习大模型 AI ？

由于新岗位的生产效率，要优于被取代岗位的生产效率，所以实际上整个社会的生产效率是提升的。

但是具体到个人，只能说是：

“最先掌握AI的人，将会比较晚掌握AI的人有竞争优势”。

这句话，放在计算机、互联网、移动互联网的开局时期，都是一样的道理。

我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。

我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在人工智能学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。但苦于知识传播途径有限，很多互联网行业朋友无法获得正确的资料得到学习提升，故此将并将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

一直在更新，更多的大模型学习和面试资料已经上传带到CSDN的官方了，有需要的朋友可以扫描下方二维码免费领取【保证100%免费】👇👇

01.大模型风口已至：月薪30K+的AI岗正在批量诞生

2025年大模型应用呈现爆发式增长，根据工信部最新数据：

国内大模型相关岗位缺口达47万

初级工程师平均薪资28K（数据来源：BOSS直聘报告）

70%企业存在"能用模型不会调优"的痛点

真实案例：某二本机械专业学员，通过4个月系统学习，成功拿到某AI医疗公司大模型优化岗offer，薪资直接翻3倍！

02.大模型 AI 学习和面试资料

1️⃣ 提示词工程：把ChatGPT从玩具变成生产工具
2️⃣ RAG系统：让大模型精准输出行业知识
3️⃣ 智能体开发：用AutoGPT打造24小时数字员工

📦熬了三个大夜整理的《AI进化工具包》送你：
✔️ 大厂内部LLM落地手册（含58个真实案例）
✔️ 提示词设计模板库（覆盖12大应用场景）
✔️ 私藏学习路径图（0基础到项目实战仅需90天）

第一阶段（10天）：初阶应用

该阶段让大家对大模型 AI有一个最前沿的认识，对大模型 AI 的理解超过 95% 的人，可以在相关讨论时发表高级、不跟风、又接地气的见解，别人只会和 AI 聊天，而你能调教 AI，并能用代码将大模型和业务衔接。

• 大模型 AI 能干什么？
• 大模型是怎样获得「智能」的？
• 用好 AI 的核心心法
• 大模型应用业务架构
• 大模型应用技术架构
• 代码示例：向 GPT-3.5 灌入新知识
• 提示工程的意义和核心思想
• Prompt 典型构成
• 指令调优方法论
• 思维链和思维树
• Prompt 攻击和防范
• …

第二阶段（30天）：高阶应用

该阶段我们正式进入大模型 AI 进阶实战学习，学会构造私有知识库，扩展 AI 的能力。快速开发一个完整的基于 agent 对话机器人。掌握功能最强的大模型开发框架，抓住最新的技术进展，适合 Python 和 JavaScript 程序员。

• 为什么要做 RAG
• 搭建一个简单的 ChatPDF
• 检索的基础概念
• 什么是向量表示（Embeddings）
• 向量数据库与向量检索
• 基于向量检索的 RAG
• 搭建 RAG 系统的扩展知识
• 混合检索与 RAG-Fusion 简介
• 向量模型本地部署
• …

第三阶段（30天）：模型训练

恭喜你，如果学到这里，你基本可以找到一份大模型 AI相关的工作，自己也能训练 GPT 了！通过微调，训练自己的垂直大模型，能独立训练开源多模态大模型，掌握更多技术方案。

到此为止，大概2个月的时间。你已经成为了一名“AI小子”。那么你还想往下探索吗？

• 为什么要做 RAG
• 什么是模型
• 什么是模型训练
• 求解器 & 损失函数简介
• 小实验2：手写一个简单的神经网络并训练它
• 什么是训练/预训练/微调/轻量化微调
• Transformer结构简介
• 轻量化微调
• 实验数据集的构建
• …

第四阶段（20天）：商业闭环

对全球大模型从性能、吞吐量、成本等方面有一定的认知，可以在云端和本地等多种环境下部署大模型，找到适合自己的项目/创业方向，做一名被 AI 武装的产品经理。

• 硬件选型
• 带你了解全球大模型
• 使用国产大模型服务
• 搭建 OpenAI 代理
• 热身：基于阿里云 PAI 部署 Stable Diffusion
• 在本地计算机运行大模型
• 大模型的私有化部署
• 基于 vLLM 部署大模型
• 案例：如何优雅地在阿里云私有部署开源大模型
• 部署一套开源 LLM 项目
• 内容安全
• 互联网信息服务算法备案
• …

学习是一个过程，只要学习就会有挑战。天道酬勤，你越努力，就会成为越优秀的自己。

如果你能在15天内完成所有的任务，那你堪称天才。然而，如果你能完成 60-70% 的内容，你就已经开始具备成为一名大模型 AI 的正确特征了。

这份完整版的大模型 AI 学习资料已经上传CSDN，朋友们如果需要可以微信扫描下方CSDN官方认证二维码免费领取【保证100%免费】