本教程展示了如何利用 渐进式披露 (Progressive Disclosure) —— 一种按需加载信息而非预先加载所有信息的上下文管理技术 —— 来实现 技能 (Skills)（基于提示词的专门化指令）。智能体通过工具调用来加载技能，而不是动态更改系统提示词，从而针对每个任务仅发现并加载其所需的技能。

使用场景： 想象一下，你正在构建一个智能体，协助编写跨越大型企业不同业务垂直领域的 SQL 查询。你的组织可能为每个垂直领域设有独立的数据库，或者拥有一个包含数千张表的单体数据库。无论哪种情况，预先加载所有模式（Schemas）都会使上下文窗口过载。渐进式披露通过仅在需要时加载相关的模式来解决这个问题。这种架构还允许不同的产品负责人和利益相关者独立地贡献并维护其特定业务领域的技能。

你将构建什么： 一个具备两项技能（销售分析和库存管理）的 SQL 查询助手。智能体在其系统提示词中只能看到轻量级的技能描述，仅当与用户查询相关时，才会通过工具调用加载完整的数据库模式和业务逻辑。

对于包含查询执行、错误纠正和验证的更完整 SQL 智能体示例，请参阅我们的 [SQL 智能体教程]。本教程重点关注可应用于任何领域的渐进式披露模式。

渐进式披露作为一种构建可扩展智能体技能系统的技术，由 Anthropic 推广。这种方法采用三层架构（元数据 → 核心内容 → 详细资源），智能体仅在需要时加载信息。有关此技术的更多信息，请参阅 [Equipping agents for the real world with Agent Skills]。

---

工作原理 (How it works)

以下是用户请求 SQL 查询时的流程：

为什么采用渐进式披露 (Why progressive disclosure)：

• 减少上下文占用 —— 每次任务仅加载所需的 2-3 项技能，而非所有可用技能。
• 赋能团队自治 —— 不同团队可以独立开发专业技能（类似于其他多智能体架构）。
• 高效扩展 —— 可以添加几十甚至上百项技能，而不会撑破上下文窗口。
• 简化对话历史 —— 保持单智能体架构，仅需维护一条对话线程。

什么是技能 (What are skills)： “技能”这一概念由 Claude Code 推广，主要基于提示词（Prompt）：它是针对特定业务任务的、自包含的专门化指令单元。在 Claude Code 中，技能以文件系统中的目录和文件形式存在，通过文件操作进行发现。技能通过提示词引导行为，并能提供工具使用信息，或包含供编码智能体执行的示例代码。

结合了渐进式披露的技能可以被视为一种 RAG（检索增强生成） 形式，其中每项技能都是一个检索单元——尽管它不一定依赖向量嵌入（Embeddings）或关键词搜索，而是通过内容浏览工具（如文件操作，或本教程中的直接查询）来实现。

权衡 (Trade-offs)：

• 延迟： 按需加载技能需要额外的工具调用，这会增加首次请求该技能时的延迟。
• 工作流控制： 基础实现依赖提示词来引导技能的使用——如果没有自定义逻辑，你无法强制执行硬性约束（例如“始终先尝试技能 A 再尝试技能 B”）。

---

实现你自己的技能系统 (Implementing your own skills system)
当你构建自己的技能实现时（如本教程所示），核心理念是渐进式披露——按需加载信息。在此基础上，你在实现上拥有完全的灵活性：

• 存储： 数据库、S3、内存数据结构或任何后端。
• 发现： 直接查询（本教程采用）、针对大规模技能库的 RAG、文件系统扫描或 API 调用。
• 加载逻辑： 自定义延迟特性，并添加搜索技能内容或进行相关性排序的逻辑。
• 其他作用： 定义加载技能时会发生什么，例如暴露出与该技能关联的工具（详见第 8 节）。
  这种灵活性让你能够针对性能、存储和工作流控制的特定需求进行优化。

---

环境搭建 (Setup)
本教程需要安装 langchain 相关包：

pip install langchain
# uv
uv add langchain

选择 LLM

从 LangChain 的集成套件中选择一个聊天模型。这里以 Google Gemini 为例：

pip install -U "langchain[google-genai]"

import os
from langchain.chat_models import init_chat_model

os.environ["GOOGLE_API_KEY"] = "..."
# 初始化模型
model = init_chat_model("google_genai:gemini-2.5-flash-lite")

---

1. 定义技能 (Define skills)

首先，定义技能的结构。每个技能包含一个名称、一段简短描述（显示在系统提示词中）和完整内容（按需加载）：

from typing import TypedDict

class Skill(TypedDict):
    """可以逐步披露给智能体的技能。"""
    name: str         # 技能的唯一标识符
    description: str  # 显示在系统提示词中的 1-2 句简短描述
    content: str      # 包含详细指令的完整技能内容

现在为 SQL 查询助手定义示例技能。这些技能的设计原则是：描述轻量化（预先展示给智能体），但内容详细（仅在需要时加载）：

# 定义技能列表
SKILLS = [
    {
        "name": "sales_analytics",
        "description": "用于查询销售额、订单、客户人口统计数据和收入趋势。",
        "content": """# 销售分析模式 (Sales Analytics Schema)

## 表结构 (Tables)

### customers (客户表)
- customer_id (主键)
- name (姓名)
- email (邮箱)
- signup_date (注册日期)
- status (状态：active/inactive)
- customer_tier (客户等级：bronze/silver/gold/platinum)

### orders (订单表)
- order_id (主键)
- customer_id (外键 -> customers)
- order_date (订单日期)
- status (状态：pending/completed/cancelled/refunded)
- total_amount (总金额)
- sales_region (销售区域：north/south/east/west)

### order_items
- item_id (PRIMARY KEY)
- order_id (FOREIGN KEY -> orders)
- product_id
- quantity
- unit_price
- discount_percent

## 业务逻辑 (Business Logic)
- **高价值订单**: 指 `total_amount > 1000` 的订单。
- **营收计算**: 仅统计 `status = 'completed'` 的订单。
- **活跃客户**: 过去 30 天内至少有一个 completed 订单的客户。

## SQL 查询示例
 Get top 10 customers by revenue in the last quarter
SELECT
    c.customer_id,
    c.name,
    c.customer_tier,
    SUM(o.total_amount) as total_revenue
FROM customers c
JOIN orders o ON c.customer_id = o.customer_id
WHERE o.status = 'completed'
  AND o.order_date >= CURRENT_DATE - INTERVAL '3 months'
GROUP BY c.customer_id, c.name, c.customer_tier
ORDER BY total_revenue DESC
LIMIT 10;
""",
    },
    {
        "name": "inventory_management",
        "description": "用于查询库存水平、仓库位置、供应商信息和补货状态。",
        "content": """# 库存管理模式 (Inventory Management Schema)

## 表结构 (Tables)

### products (产品表)
- product_id (PRIMARY KEY)
- product_name
- sku
- category
- unit_cost
- reorder_point (minimum stock level before reordering)
- discontinued (boolean)

### warehouses
- warehouse_id (PRIMARY KEY)
- warehouse_name
- location
- capacity

### inventory
- inventory_id (PRIMARY KEY)
- product_id (FOREIGN KEY -> products)
- warehouse_id (FOREIGN KEY -> warehouses)
- quantity_on_hand
- last_updated

### stock_movements
- movement_id (PRIMARY KEY)
- product_id (FOREIGN KEY -> products)
- warehouse_id (FOREIGN KEY -> warehouses)
- movement_type (inbound/outbound/transfer/adjustment)
- quantity (positive for inbound, negative for outbound)
- movement_date
- reference_number


## 业务逻辑 (Business Logic)

**可用库存 (Available stock)**：库存表中的 `quantity_on_hand`，且 `quantity_on_hand > 0`。
**需要重新订货的产品 (Products needing reorder)**：所有仓库中 `quantity_on_hand` 的总和小于或等于该产品 `reorder_point`（重订货点）的产品。
**仅限活跃产品 (Active products only)**：排除 `discontinued = true`（已停产）的产品，除非专门分析停产项目。
**库存估值 (Stock valuation)**：针对每个产品，计算 `quantity_on_hand * unit_cost`。

## SQL 查询示例
-- Find products below reorder point across all warehouses
SELECT
    p.product_id,
    p.product_name,
    p.reorder_point,
    SUM(i.quantity_on_hand) as total_stock,
    p.unit_cost,
    (p.reorder_point - SUM(i.quantity_on_hand)) as units_to_reorder
FROM products p
JOIN inventory i ON p.product_id = i.product_id
WHERE p.discontinued = false
GROUP BY p.product_id, p.product_name, p.reorder_point, p.unit_cost
HAVING SUM(i.quantity_on_hand) <= p.reorder_point
ORDER BY units_to_reorder DESC;
"""
    }
]

2. 创建技能加载工具 (Create skill loading tool)

创建一个用于按需加载完整技能内容的工具：

from langchain.tools import tool

@tool
def load_skill(skill_name: str) -> str:
    """将技能的完整内容加载到智能体的上下文中。
    当你需要关于如何处理特定类型请求的详细信息时，请使用此工具。
    这将为你提供该技能领域的全面指令、政策和指南。
    参数:
        skill_name: 要加载的技能名称 (例如 "expense_reporting", "travel_booking")
    """
    # 查找并返回请求的技能
    for skill in SKILLS:
        if skill["name"] == skill_name:
            return f"已加载技能: {skill_name}\n\n{skill['content']}"
    
    # 未找到技能
    available = ", ".join(s["name"] for s in SKILLS)
    return f"未找到技能 '{skill_name}'。可用技能: {available}"

load_skill 工具以字符串形式返回完整的技能内容，该内容作为 ToolMessage 成为对话的一部分。有关创建和使用工具的更多详细信息，请参阅[工具指南]。

---

3. 构建技能中间件 (Build skill middleware)

创建自定义中间件，将技能描述注入系统提示词。该中间件使技能变得可被发现，而无需预先加载其完整内容。

本指南演示了如何创建自定义中间件。有关中间件概念和模式的全面指南，请参阅[自定义中间件文档]。

from langchain.agents.middleware import ModelRequest, ModelResponse, AgentMiddleware
from langchain.messages import SystemMessage
from typing import Callable

class SkillMiddleware(AgentMiddleware):
    """将技能描述注入系统提示词的中间件。"""
    # 将 load_skill 工具注册为类变量
    tools = [load_skill]

    def __init__(self):
        """初始化并从 SKILLS 中生成技能提示词。"""
        # 从 SKILLS 列表中构建技能提示词
        skills_list = []
        for skill in SKILLS:
            skills_list.append(
                f"- **{skill['name']}**: {skill['description']}"
            )
        self.skills_prompt = "\n".join(skills_list)

    def wrap_model_call(
        self,
        request: ModelRequest,
        handler: Callable[[ModelRequest], ModelResponse],
    ) -> ModelResponse:
        """同步方法：将技能描述注入系统提示词。"""
        # 构建技能补充内容
        skills_addendum = (
             f"\n\n## 可用技能\n\n{self.skills_prompt}\n\n"
            "当你需要处理特定类型请求的详细信息时，请使用 load_skill 工具。"
        )
        # 附加到系统消息的内容块中
        new_content = list(request.system_message.content_blocks) + [
            {"type": "text", "text": skills_addendum}
        ]
        new_system_message = SystemMessage(content=new_content)
        modified_request = request.override(system_message=new_system_message)
        return handler(modified_request)

中间件将技能描述附加到系统提示词中，使智能体能够意识到可用技能而无需加载其完整内容。load_skill 工具被注册为类变量，使其对智能体可用。

生产环境考量： 为简单起见，本教程在 __init__ 中加载技能列表。在生产系统中，你可能希望在 before_agent 钩子中加载技能，从而允许定期刷新技能以反映最新更改（例如，当添加新技能或修改现有技能时）。有关详细信息，请参阅 [before_agent 钩子文档]。

4. 创建具备技能支持的智能体 (Create the agent with skill support)

现在，使用技能中间件和用于状态持久化的检查点（checkpointer）来创建智能体：

from langchain.agents import create_agent
from langgraph.checkpoint.memory import InMemorySaver

# 创建具备技能支持的智能体
agent = create_agent(
    model,
    system_prompt=(
        "你是一个 SQL 查询助手，帮助用户"
        "针对业务数据库编写查询语句。"
    ),
    middleware=[SkillMiddleware()],      
    checkpointer=InMemorySaver(),
)

现在，智能体可以在其系统提示词中访问技能描述，并能在需要时调用 load_skill 来检索完整的技能内容。检查点负责维护跨轮次的对话历史。

---

5. 测试渐进式披露 (Test progressive disclosure)

使用一个需要特定技能知识的问题来测试智能体：

import uuid

# 此对话线程的配置
thread_id = str(uuid.uuid4())
config = {"configurable": {"thread_id": thread_id}}

# 请求 SQL 查询
result = agent.invoke(
      {
        "messages": [
            {
                "role": "user",
                "content": (
                    "编写一个 SQL 查询，查找在过去一个月内"
                    "订单金额超过 $1000 的所有客户"
                ),
            }
        ]
    },
    config
)

# 打印对话内容
for message in result["messages"]:
    if hasattr(message, 'pretty_print'):
        message.pretty_print()
    else:
        print(f"{message.type}: {message.content}")

输出示例：

================================ Human Message =================================

Write a SQL query to find all customers who made orders over $1000 in the last month
================================== Ai Message ==================================
Tool Calls:
  load_skill (call_abc123)
 Call ID: call_abc123
  Args:
    skill_name: sales_analytics
================================= Tool Message =================================
Name: load_skill

Loaded skill: sales_analytics

# Sales Analytics Schema

## Tables

### customers
- customer_id (PRIMARY KEY)
- name
- email
- signup_date
- status (active/inactive)
- customer_tier (bronze/silver/gold/platinum)

### orders
- order_id (PRIMARY KEY)
- customer_id (FOREIGN KEY -> customers)
- order_date
- status (pending/completed/cancelled/refunded)
- total_amount
- sales_region (north/south/east/west)

[... rest of schema ...]

## Business Logic

**High-value orders**: Orders with `total_amount > 1000`
**Revenue calculation**: Only count orders with `status = 'completed'`

================================== Ai Message ==================================

Here's a SQL query to find all customers who made orders over $1000 in the last month:

\`\`\`sql
SELECT DISTINCT
    c.customer_id,
    c.name,
    c.email,
    c.customer_tier
FROM customers c
JOIN orders o ON c.customer_id = o.customer_id
WHERE o.total_amount > 1000
  AND o.status = 'completed'
  AND o.order_date >= CURRENT_DATE - INTERVAL '1 month'
ORDER BY c.customer_id;
\`\`\`

This query:
- Joins customers with their orders
- Filters for high-value orders (>$1000) using the total_amount field
- Only includes completed orders (as per the business logic)
- Restricts to orders from the last month
- Returns distinct customers to avoid duplicates if they made multiple qualifying orders

6. 进阶：使用自定义状态添加约束 (Advanced: Add constraints with custom state)

可选：跟踪已加载的技能并强制执行工具约束
你可以添加约束，以强制某些工具只有在加载了特定技能后才可用。这需要通过自定义智能体状态（Custom Agent State）来跟踪哪些技能已被加载。

---

定义自定义状态 (Define custom state)

首先，扩展智能体状态以跟踪已加载的技能：

from typing_extensions import NotRequired
from langchain.agents.middleware import AgentState

class CustomState(AgentState):      
    skills_loaded: NotRequired[list[str]]  # 跟踪哪些技能已被加载

---

更新 load_skill 以修改状态 (Update load_skill to modify state)

修改 load_skill 工具，使其在加载技能时更新状态：

from langgraph.types import Command  
from langchain.tools import tool, ToolRuntime
from langchain.messages import ToolMessage  

@tool
def load_skill(skill_name: str, runtime: ToolRuntime) -> Command:      
    """将技能的完整内容加载到智能体的上下文中。
    当你需要关于如何处理特定类型请求的详细信息时，请使用此工具。
    参数:
        skill_name: 要加载的技能名称
    """
    # 查找并返回请求的技能
    for skill in SKILLS:
        if skill["name"] == skill_name:
            skill_content = f"已加载技能: {skill_name}\n\n{skill['content']}"
            # 返回 Command 以更新状态并跟踪已加载的技能
            return Command(                  
                update={                      
                    "messages": [                          
                        ToolMessage(                              
                            content=skill_content,                              
                            tool_call_id=runtime.tool_call_id,                          
                        )                      
                    ],                      
                    "skills_loaded": [skill_name],                  
                }              
            )      

    # 未找到技能
    available = ", ".join(s["name"] for s in SKILLS)
    return Command(
        update={
            "messages": [
                ToolMessage(
                    content=f"未找到技能 '{skill_name}'。可用技能: {available}",
                    tool_call_id=runtime.tool_call_id,
                )
            ]
        }
    )

---

创建受限工具 (Create constrained tool)

创建一个只有在加载了特定技能后才能使用的工具：

@tool
def write_sql_query(      
    query: str,    
    vertical: str,    
    runtime: ToolRuntime,
) -> str:    
    """为特定的业务领域编写并验证 SQL 查询。
    此工具有助于格式化和验证 SQL 查询。你必须先加载相应的技能以了解数据库模式。
    参数:
        query: 要编写的 SQL 查询
        vertical: 业务领域 (sales_analytics 或 inventory_management)
    """
    # 检查所需的技能是否已加载
    skills_loaded = runtime.state.get("skills_loaded", [])      
    
    if vertical not in skills_loaded:          
        return (              
            f"错误：你必须先加载 '{vertical}' 技能才能在编写查询前理解数据库模式。"
            f"请使用 load_skill('{vertical}') 来加载模式。"        
        )      

    # 验证并格式化查询
    return (
        f"针对 {vertical} 的 SQL 查询：\n\n"
        f"```sql\n{query}\n```\n\n"
        f"✓ 查询已针对 {vertical} 模式完成验证\n"
        f"已准备好在数据库中执行。"
    )

---

更新中间件和智能体 (Update middleware and agent)

更新中间件以使用自定义状态模式：

class SkillMiddleware(AgentMiddleware[CustomState]):      
    """将技能描述注入系统提示词的中间件。"""
    state_schema = CustomState      
    
    # 注册工具列表，包括受限工具
    tools = [load_skill, write_sql_query]      
    # ... 中间件的其余实现保持不变

创建注册了受限工具中间件的智能体：

agent = create_agent(
    model,
    system_prompt=(
        "你是一个 SQL 查询助手，帮助用户"
        "针对业务数据库编写查询语句。"
    ),
    middleware=[SkillMiddleware()],      
    checkpointer=InMemorySaver(),
)

现在，如果智能体在加载所需技能之前尝试使用 write_sql_query，它将收到一条错误消息，提示其先加载相应的技能（例如 sales_analytics 或 inventory_management）。这确保了智能体在尝试验证查询之前已具备必要的模式知识。

---

7. 完整示例 (Complete example)

以下是一个结合了本教程所有部分的完整、可运行的实现代码：

import uuid
from typing import TypedDict, NotRequired, Callable
from langchain.tools import tool
from langchain.agents import create_agent
from langchain.agents.middleware import ModelRequest, ModelResponse, AgentMiddleware
from langchain.messages import SystemMessage
from langgraph.checkpoint.memory import InMemorySaver
from langchain_openai import ChatOpenAI

# 1. 定义技能结构
class Skill(TypedDict):
    """可以逐步披露给智能体的技能。"""
    name: str
    description: str
    content: str

# 2. 定义包含模式（Schema）和业务逻辑的技能库
SKILLS: list[Skill] = [
    {
        "name": "sales_analytics",
        "description": "包含客户、订单和收入在内的销售数据分析的数据库模式及业务逻辑。",
        "content": """# 销售分析模式
## 表结构
### customers
- customer_id (主键)
- name, email, signup_date
- status (active/inactive)
- customer_tier (bronze/silver/gold/platinum)
### orders
- order_id (主键), customer_id (外键), order_date
- status (pending/completed/cancelled/refunded)
- total_amount, sales_region
## 业务逻辑
**活跃客户**: status = 'active' 且注册日期在 90 天前。
**营收计算**: 仅统计已完成 (completed) 的订单。
**高价值订单**: 订单金额 > 1000。""",
    },
    {
        "name": "inventory_management",
        "description": "包含产品、仓库和库存水平在内的库存跟踪数据库模式及业务逻辑。",
        "content": """# 库存管理模式
## 表结构
### products
- product_id (主键), product_name, sku, category, unit_cost, reorder_point, discontinued
### inventory
- inventory_id (主键), product_id (外键), warehouse_id (外键), quantity_on_hand
## 业务逻辑
**可用库存**: inventory 表中 quantity_on_hand > 0 的记录。
**需要补货的产品**: 各仓库库存总和小于等于重订货点 (reorder_point) 的产品。""",
    },
]

# 3. 创建技能加载工具
@tool
def load_skill(skill_name: str) -> str:
    """按需将技能的完整内容加载到智能体上下文中。"""
    for skill in SKILLS:
        if skill["name"] == skill_name:
            return f"已加载技能: {skill_name}\n\n{skill['content']}"
    available = ", ".join(s["name"] for s in SKILLS)
    return f"未找到技能 '{skill_name}'。可用技能: {available}"

# 4. 创建技能中间件
class SkillMiddleware(AgentMiddleware):
    """将技能描述注入系统提示词的中间件。"""
    tools = [load_skill]
    def __init__(self):
        skills_list = [f"- **{s['name']}**: {s['description']}" for s in SKILLS]
        self.skills_prompt = "\n".join(skills_list)

    def wrap_model_call(self, request: ModelRequest, handler: Callable[[ModelRequest], ModelResponse]) -> ModelResponse:
        skills_addendum = (
            f"\n\n## 可用技能\n\n{self.skills_prompt}\n\n"
            "需要特定领域的详细信息时，请使用 load_skill 工具。"
        )
        new_content = list(request.system_message.content_blocks) + [{"type": "text", "text": skills_addendum}]
        new_system_message = SystemMessage(content=new_content)
        modified_request = request.override(system_message=new_system_message)
        return handler(modified_request)

# 5. 初始化模型并创建智能体
model = ChatOpenAI(model="gpt-4")
agent = create_agent(
    model,
    system_prompt="你是一个 SQL 查询助手，帮助用户编写业务数据库查询语句。",
    middleware=[SkillMiddleware()],
    checkpointer=InMemorySaver(),
)

# 6. 示例用法
if __name__ == "__main__":
    thread_id = str(uuid.uuid4())
    config = {"configurable": {"thread_id": thread_id}}
    
    result = agent.invoke(
        {"messages": [{"role": "user", "content": "写一个 SQL 查询，查找上个月订单超过 $1000 的所有客户"}]},
        config
    )

    for message in result["messages"]:
        message.pretty_print()

---

该完整示例包含：

• 包含完整数据库模式的技能定义。
• 用于按需加载的 load_skill 工具。
• 将技能描述注入系统提示词的 SkillMiddleware。
• 集成中间件和检查点（状态持久化）的智能体创建。
• 展示智能体如何加载技能并编写 SQL 查询的示例用法。

运行步骤：

1. 安装必要包：pip install langchain langchain-openai langgraph
2. 设置 API 密钥：(例如 export OPENAI_API_KEY=...)
3. 模型初始化：根据你偏好的 LLM 供应商替换模型初始化部分。

---

8. 实施变体 (Implementation variations)

本教程将“技能”实现为通过工具调用加载的内存 Python 字典。然而，实现技能的渐进式披露还有多种方式：

存储后端 (Storage backends)：

• 内存 (In-memory)（本教程采用）：将技能定义为 Python 数据结构，访问速度快，无 I/O 开销。
• 文件系统 (File system)（Claude Code 方法）：将技能存放在带有文件的目录中，通过 read_file 等文件操作进行发现。
• 远程存储 (Remote storage)：将技能存放在 S3、数据库、Notion 或 API 中，按需获取。

技能发现 (Skill discovery) —— 智能体如何得知存在哪些技能：

• 系统提示词列表 (System prompt listing)：在系统提示词中列出技能描述（本教程采用）。
• 基于文件 (File-based)：通过扫描目录来发现技能（Claude Code 方法）。
• 基于注册表 (Registry-based)：查询技能注册服务或 API 以获取可用技能。
• 动态查询 (Dynamic lookup)：通过工具调用来列出可用技能。

渐进式披露策略 (Progressive disclosure strategies) —— 技能内容如何加载：

• 单次加载 (Single load)：通过一次工具调用加载整个技能内容（本教程采用）。
• 分页加载 (Paginated)：针对大型技能，分多个页面或分块加载。
• 基于搜索 (Search-based)：在特定技能内容中搜索相关部分（例如，对技能文件使用 grep 或读取操作）。
• 层级化加载 (Hierarchical)：先加载技能概览，再深入探索具体的子章节。

尺寸考量 (Size considerations) —— 针对你的系统进行优化的非校准心理模型：

• 小型技能 (< 1K tokens / ~750 词)：可以直接包含在系统提示词中，并结合提示词缓存（Prompt Caching）以节省成本并加快响应。
• 中型技能 (1-10K tokens / ~750-7.5K 词)：受益于按需加载，以避免上下文开销（本教程采用）。
• 大型技能 (> 10K tokens / ~7.5K 词，或占上下文窗口的 5-10% 以上)：应使用分页、搜索式加载或层级探索等渐进式披露技术，以避免消耗过多的上下文。

选择依据： 内存方式最快，但更新技能需要重新部署；而基于文件或远程存储的方式则支持在不更改代码的情况下进行动态技能管理。

9. 总结

结合少样本提示 (Few-shot prompting) 及其他技术

渐进式披露从根本上说是一种上下文工程技术——即管理在何时将哪些信息提供给智能体。本教程虽然侧重于加载数据库模式（Schema），但同样的原则也适用于其他类型的上下文。

结合少样本提示词 (Combining with few-shot prompting)

针对 SQL 查询的使用场景，你可以扩展渐进式披露模式，根据用户的查询动态加载少样本示例 (Few-shot examples)：

示例方法：

1. 用户提问：“查找 6 个月没有下单的客户。”
2. 智能体加载 sales_analytics 模式（如本教程所示）。
3. 智能体同时加载 2-3 个相关的示例查询（通过语义搜索或基于标签的查找）：

• 用于查找非活跃客户的查询示例。
• 包含日期过滤逻辑的查询示例。
• 包含客户表与订单表关联（Join）的查询示例。

4. 智能体编写查询：同时利用模式知识和示例中的模式（Pattern）。

这种将渐进式披露（按需加载模式）与动态少样本提示（加载相关示例）相结合的方法，创造了一种强大的上下文工程模式。它既能扩展到庞大的知识库，又能提供高质量、有据可依（Grounded）的输出。