System Prompt工程化实践：让AI"人设"不崩塌的艺术
想象一下，你请了一位顶级厨师来家里做饭。如果你只说"做个好吃的"，他可能会端出一盘法式鹅肝——但你其实想要的是家常红烧肉。System Prompt就是那个**"点菜说明书"**，它决定了AI是变成严谨的程序员、贴心的客服，还是毒舌的评论家。
今天，我们就来聊聊如何把这份"说明书"写得既专业又优雅。
一、静态Prompt：AI的"基础人设"
静态Prompt就像给AI设定的出厂配置，决定了它的基本性格和行为模式。
1. 基础结构：角色-任务-约束三板斧
from langchain_core.prompts import ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate
# 一个优秀的System Prompt应该包含三个要素
system_template = """你是一位{role}。你的任务是{task}。
【行为准则】
1. {rule_1}
2. {rule_2}
3. {rule_3}
【输出格式】
{output_format}
【注意事项】
{warnings}
"""
prompt = ChatPromptTemplate.from_messages([
SystemMessagePromptTemplate.from_template(system_template),
HumanMessagePromptTemplate.from_template("{user_input}")
])
# 实例化：让AI变成"代码审查员"
code_reviewer_prompt = prompt.partial(
role="资深Python代码审查专家，拥有10年开源项目维护经验",
task="审查用户提供的代码，找出潜在bug、性能瓶颈和不符合PEP8规范的地方",
rule_1="先肯定代码的优点，再指出问题，保持建设性态度",
rule_2="对严重问题（如安全隐患）使用[严重]标签，一般建议使用[建议]标签",
rule_3="提供具体的修改示例，不要只讲理论",
output_format="""## 审查摘要
总体评分：X/10
## 发现的问题
1. [严重/建议] 问题描述
- 位置：行号X
- 修复建议：代码示例
## 优点亮点
...""",
warnings="不要修改代码的功能逻辑，只优化实现方式"
)
2. 进阶技巧：Few-Shot嵌入
让AI"看几个例子"往往比长篇大论更有效：
from langchain_core.prompts import FewShotChatMessagePromptTemplate
# 定义示例对话
examples = [
{
"input": "帮我写个快速排序",
"output": """```python
def quicksort(arr):
if len(arr) <= 1:
return arr
pivot = arr[len(arr) // 2]
left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]
return quicksort(left) + middle + quicksort(right)```
复杂度：O(n log n)平均，O(n²)最坏情况。适用于大数据集，但非稳定排序。"""
},
{
"input": "这段代码有什么问题？def add(a,b): return a+b",
"output": """功能上没问题，但可以更Pythonic：
```python
def add(a: int, b: int) -> int:
\"\"\"返回两个数的和。\"\"\"
return a + b```
改进点：
1. 添加类型注解
2. 添加文档字符串
3. 考虑异常处理（如输入非数字类型）"""
}
]
example_prompt = ChatPromptTemplate.from_messages([
("human", "{input}"),
("ai", "{output}")
])
few_shot_prompt = FewShotChatMessagePromptTemplate(
example_prompt=example_prompt,
examples=examples,
)
final_prompt = ChatPromptTemplate.from_messages([
("system", "你是一位代码助手，遵循以下示例的风格回答问题："),
few_shot_prompt,
("human", "{user_input}")
])
3. 模块化Prompt管理
当项目变大，Prompt也需要"工程化"管理：
# prompts/configs/base.py
from dataclasses import dataclass
from typing import List, Optional
@dataclass
class PromptConfig:
"""Prompt配置类，便于版本管理和A/B测试"""
name: str
version: str
system_template: str
variables: List[str]
temperature: float = 0.7
max_tokens: Optional[int] = None
def format(self, **kwargs) -> str:
return self.system_template.format(**kwargs)
# prompts/characters/coder.py
coder_config = PromptConfig(
name="python_coder",
version="1.2.0",
system_template="""你是一位{expertise}Python开发者。
风格偏好：{style}
代码标准：遵循{standard}规范。
{additional_context}""",
variables=["expertise", "style", "standard", "additional_context"],
temperature=0.2, # 代码需要确定性
max_tokens=2000
)
# 使用示例
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(temperature=coder_config.temperature)
formatted_prompt = coder_config.format(
expertise="擅长高性能计算和算法优化的",
style="简洁优雅，注重注释",
standard="Google Python Style Guide",
additional_context="当前项目使用Python 3.11，依赖numpy和pandas"
)
二、动态Prompt：让AI"见人说人话"
静态Prompt像制服，动态Prompt像智能变色衣——根据场景自动调整。
1. 使用函数动态生成Prompt
from typing import Dict, Any
from langchain_core.prompts import SystemMessage
def generate_dynamic_prompt(
user_context: Dict[str, Any],
conversation_history: list,
available_tools: list
) -> SystemMessage:
"""
根据用户状态动态构建System Prompt
就像根据客人忌口调整菜谱
"""
# 基础人设
base_persona = "你是一位智能助手。"
# 根据用户经验水平调整深度
experience_level = user_context.get("experience_level", "intermediate")
depth_instructions = {
"beginner": "使用简单类比解释概念，避免术语，多举生活例子。",
"intermediate": "可以适当使用专业术语，但需要简要解释。",
"expert": "直接深入技术细节，无需解释基础概念。"
}
# 根据可用工具调整能力描述
tool_capabilities = ""
if available_tools:
tool_list = ", ".join([t.name for t in available_tools])
tool_capabilities = f"你可以使用以下工具：{tool_list}。使用工具时先说明意图。"
# 根据对话历史调整语气
message_count = len(conversation_history)
if message_count > 10:
rapport = "你们已经交流一段时间了，可以保持友好轻松的语气，适当使用之前的上下文。"
else:
rapport = "保持专业、清晰的初次交流风格。"
# 组装最终Prompt
dynamic_content = f"""{base_persona}
【当前用户画像】
经验水平：{experience_level}
{depth_instructions[experience_level]}
【能力范围】
{tool_capabilities}
【对话风格】
{rapport}
【当前会话信息】
已交互轮数：{message_count}
用户ID：{user_context.get('user_id', 'anonymous')}
"""
return SystemMessage(content=dynamic_content)
# 使用示例
context = {
"user_id": "user_123",
"experience_level": "beginner",
"preferred_language": "zh"
}
history = [] # 实际应该是历史消息列表
tools = [] # 实际注册的工具
system_msg = generate_dynamic_prompt(context, history, tools)
2. LangChain的@dynamic_prompt风格实现
虽然LangChain没有内置@dynamic_prompt装饰器，但我们可以这样实现类似功能：
from functools import wraps
from typing import Callable, Union
from langchain_core.messages import SystemMessage
class DynamicPromptRegistry:
"""动态Prompt注册中心，类似中间件机制"""
def __init__(self):
self.generators: Dict[str, Callable] = {}
def register(self, name: str):
def decorator(func: Callable):
self.generators[name] = func
@wraps(func)
def wrapper(*args, **kwargs):
return func(*args, **kwargs)
return wrapper
return decorator
def generate(self, name: str, context: Dict) -> SystemMessage:
if name not in self.generators:
raise ValueError(f"Unknown prompt generator: {name}")
return self.generators[name](context)
# 全局注册表
prompt_registry = DynamicPromptRegistry()
# 定义不同的动态Prompt生成器
@prompt_registry.register("coding_assistant")
def coding_assistant_prompt(ctx: Dict) -> SystemMessage:
language = ctx.get("language", "Python")
difficulty = ctx.get("difficulty", "medium")
content = f"""你是一位{language}专家。
当前难度设置：{difficulty}
{'请提供详细的分步解释。' if difficulty == 'easy' else '请直接给出最优解。'}
"""
return SystemMessage(content=content)
@prompt_registry.register("writing_coach")
def writing_coach_prompt(ctx: Dict) -> SystemMessage:
genre = ctx.get("genre", "general")
tone = ctx.get("tone", "professional")
return SystemMessage(content=f"""你是一位{genre}写作教练。
语气要求：{tone}
{'注重情感共鸣和故事性' if tone == 'casual' else '注重逻辑结构和事实准确性'}
""")
# 在Agent中使用
from langchain.agents import create_openai_functions_agent
def create_adaptive_agent(registry: DynamicPromptRegistry, prompt_name: str):
def agent_factory(context: Dict):
system_msg = registry.generate(prompt_name, context)
# 结合system_msg创建agent...
return system_msg
return agent_factory
# 实际调用
context = {"language": "Rust", "difficulty": "hard"}
system_message = prompt_registry.generate("coding_assistant", context)
三、Anthropic Prompt Caching：给Prompt装个"缓存器"
想象你有一本1000页的说明书，每次提问都要翻一遍。Anthropic的Prompt Caching就是让你把常用章节"折个角"，下次直接翻到。
1. 什么是Prompt Caching？
这是Anthropic Claude模型的特色功能，允许你：
- 缓存长达128K tokens的上下文
- 后续请求只需发送增量内容
- 成本降低高达90%，延迟减少85%
2. LangChain中的实现
from langchain_anthropic import ChatAnthropic
from langchain_core.messages import SystemMessage, HumanMessage
# 初始化支持caching的模型
llm = ChatAnthropic(
model="claude-3-5-sonnet-20241022",
max_tokens=1024,
)
# 构造带缓存标记的消息
# 注意： LangChain目前对原生caching支持有限，需要手动控制API调用
from anthropic import Anthropic
import os
client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
def create_cached_conversation(
system_prompt: str, # 这部分会被缓存
permanent_context: str, # 长期知识，如产品文档
dynamic_query: str # 每次变化的问题
):
"""
构造利用Prompt Caching的消息序列
"""
response = client.messages.create(
model="claude-3-5-sonnet-20241022",
max_tokens=1024,
system=system_prompt, # System prompt自动被优化缓存
messages=[
{
"role": "user",
"content": [
{
"type": "text",
"text": permanent_context,
"cache_control": {"type": "ephemeral"} # 标记为可缓存
},
{
"type": "text",
"text": f"基于以上文档，请回答：{dynamic_query}"
# 这部分不缓存，每次都变
}
]
}
]
)
return response.content[0].text
# 实战：RAG场景下的Caching优化
class CachedRAGAssistant:
def __init__(self, system_prompt: str, document_corpus: str):
self.system = system_prompt
# 预加载并缓存大文档
self.cached_context = self._prepare_cache(document_corpus)
self.client = Anthropic()
def _prepare_cache(self, docs: str) -> str:
# 实际项目中这里会处理大量文档
return f"""【知识库内容 - 已缓存】
{docs[:100000]} # 假设这是大量文档
"""
def query(self, question: str) -> str:
# 只有question是新的，其他都走缓存
return create_cached_conversation(
system_prompt=self.system,
permanent_context=self.cached_context,
dynamic_query=question
)
# 使用示例
assistant = CachedRAGAssistant(
system_prompt="你是一位专业的技术支持工程师，基于提供的产品文档回答问题。",
document_corpus="..." # 大量产品文档
)
# 第一次调用后，文档内容被缓存
answer1 = assistant.query("如何重置密码？")
# 第二次调用，只传输问题，复用缓存的文档，速度快10倍，成本低90%
answer2 = assistant.query("支持哪些支付方式？")
3. 缓存策略最佳实践
class PromptCacheStrategy:
"""Prompt分层缓存策略"""
def __init__(self):
self.layers = {
"static": { # 永不改变，长期缓存
"content": "基础人设和全局规则",
"ttl": "permanent"
},
"semi_static": { # 小时级变化
"content": "用户画像、会话上下文",
"ttl": 3600
},
"dynamic": { # 每次请求都变
"content": "具体问题、实时数据",
"ttl": 0
}
}
def build_prompt(self, layers_data: Dict) -> list:
"""
按层次构建Prompt，优化缓存命中率
"""
messages = []
# 第一层：System（自动被Claude缓存）
messages.append({
"role": "system",
"content": layers_data["static"]
})
# 第二层：缓存的长期上下文
messages.append({
"role": "user",
"content": [
{
"type": "text",
"text": f"<context>{layers_data['semi_static']}</context>",
"cache_control": {"type": "ephemeral"}
}
]
})
# 第三层：实时问题（不缓存）
messages.append({
"role": "user",
"content": layers_data["dynamic"]
})
return messages
四、多角色Prompt模板管理：AI的"人格分裂"艺术
一个复杂的Agent系统往往需要多个专家角色协同工作，就像 Avengers（复仇者联盟）各自有专长，但听命于统一指挥。
1. 角色定义与切换机制
from enum import Enum
from dataclasses import dataclass
from typing import Dict, List
class AgentRole(Enum):
ANALYZER = "analyzer" # 分析型：逻辑严谨，注重事实
CREATIVE = "creative" # 创意型：头脑风暴，发散思维
CRITIC = "critic" # 批判型：找茬挑刺，风险评估
EXECUTOR = "executor" # 执行型：注重落地，细节导向
COORDINATOR = "coordinator" # 协调型：统筹全局，分配任务
@dataclass
class RoleProfile:
name: str
system_prompt: str
temperature: float
max_tokens: int
allowed_tools: List[str]
voice_style: str # 用于语音输出的风格提示
class MultiRolePromptManager:
"""多角色Prompt管理器"""
def __init__(self):
self.roles: Dict[AgentRole, RoleProfile] = {
AgentRole.ANALYZER: RoleProfile(
name="数据分析师",
system_prompt="""你是数据分析师Dr.Data。你的特点是：
- 只说确定的事实，不确定时明确标注"推测"
- 使用数据支撑观点，提供统计显著性
- 回答结构：结论->依据->置信度->缺失信息
- 禁止：主观臆断、情绪化表达""",
temperature=0.1, # 低温度确保确定性
max_tokens=1500,
allowed_tools=["data_query", "statistical_analysis", "visualization"],
voice_style="冷静、客观、略带学术腔"
),
AgentRole.CREATIVE: RoleProfile(
name="创意总监",
system_prompt="""你是创意总监Muse。你的特点是：
- 思维跳跃，善于跨界联想
- 使用"如果...会怎样"的提问方式
- 鼓励疯狂想法，后期再收敛
- 回答结构：核心创意->3个变体->跨界类比->实现脑洞
- 禁止：过早否定、强调不可能""",
temperature=0.9, # 高温度增加创造性
max_tokens=2000,
allowed_tools=["image_generation", "trend_search", "brainstorming"],
voice_style="热情、跳跃、充满感染力"
),
AgentRole.CRITIC: RoleProfile(
name="风险管控官",
system_prompt="""你是风险管控官Skeptic。你的特点是：
- 专门寻找逻辑漏洞和潜在风险
- 使用红队思维（Red Teaming）
- 评估法律、伦理、技术、商业四维度风险
- 回答结构：风险点->严重程度->触发条件->缓解方案
- 禁止：和稀泥、回避尖锐问题""",
temperature=0.3,
max_tokens=1200,
allowed_tools=["compliance_check", "risk_matrix", "case_study_search"],
voice_style="严肃、直接、略带警惕"
),
AgentRole.EXECUTOR: RoleProfile(
name="执行工程师",
system_prompt="""你是执行工程师Builder。你的特点是：
- 把想法变成可执行步骤
- 每个建议都包含：具体动作->负责人->截止时间->验收标准
- 优先关注资源约束和依赖关系
- 回答结构：任务分解->依赖图->风险点->检查清单
- 禁止：模糊表述、忽略落地细节""",
temperature=0.2,
max_tokens=1800,
allowed_tools=["project_management", "code_generation", "resource_planning"],
voice_style="务实、简洁、行动导向"
),
AgentRole.COORDINATOR: RoleProfile(
name="项目协调员",
system_prompt="""你是项目协调员Orchestrator。你的特点是：
- 理解各专家角色能力边界
- 将复杂任务分解并分配给合适角色
- 同步上下文，确保信息不丢失
- 回答结构：任务理解->角色分配->协作流程->同步机制
- 禁止：越俎代庖、信息不同步""",
temperature=0.4,
max_tokens=1000,
allowed_tools=["role_router", "context_sync", "progress_tracker"],
voice_style="清晰、中立、组织性强"
)
}
def get_prompt(self, role: AgentRole) -> str:
return self.roles[role].system_prompt
def get_config(self, role: AgentRole) -> Dict:
profile = self.roles[role]
return {
"temperature": profile.temperature,
"max_tokens": profile.max_tokens,
"system_prompt": profile.system_prompt
}
def switch_role(self, current_role: AgentRole, trigger: str) -> AgentRole:
"""
基于触发条件自动切换角色
就像团队会议中，根据议题自动换主讲人
"""
switch_map = {
"需要数据分析": AgentRole.ANALYZER,
"来个创意": AgentRole.CREATIVE,
"有什么风险": AgentRole.CRITIC,
"怎么落地": AgentRole.EXECUTOR,
"协调一下": AgentRole.COORDINATOR
}
for keyword, target_role in switch_map.items():
if keyword in trigger:
return target_role
return current_role
2. 多角色协作流程
from langchain_core.messages import HumanMessage, AIMessage
from langgraph.graph import StateGraph, END
class MultiRoleAgentState:
def __init__(self):
self.messages: List = []
self.current_role: AgentRole = AgentRole.COORDINATOR
self.task_queue: List = []
self.consensus: Dict = {}
class MultiRoleOrchestrator:
"""多角色协作编排器"""
def __init__(self, prompt_manager: MultiRolePromptManager):
self.pm = prompt_manager
self.graph = self._build_graph()
def _build_graph(self):
# 定义状态机：Coordinator -> 分配任务 -> 各角色执行 -> 汇总
workflow = StateGraph(MultiRoleAgentState)
# 添加节点...
# 这里简化展示核心逻辑
return workflow.compile()
def run_collaboration(self, task: str) -> str:
"""
模拟团队协作解决复杂问题
"""
# 阶段1：Coordinator分析任务
coordinator_prompt = self.pm.get_prompt(AgentRole.COORDINATOR)
plan = self._ask_role(AgentRole.COORDINATOR, f"请分析任务并制定协作计划：{task}")
# 阶段2：并行执行各子任务
results = {}
for subtask in plan.subtasks:
role = self.pm.switch_role(AgentRole.COORDINATOR, subtask.type)
role_config = self.pm.get_config(role)
results[subtask.id] = self._ask_role_with_config(role, subtask.description, role_config)
# 阶段3：Critic审查
consolidated = "\n\n".join([r.content for r in results.values()])
critique = self._ask_role(
AgentRole.CRITIC,
f"审查以下综合方案的风险：{consolidated}"
)
# 阶段4：Coordinator输出最终方案
final = self._ask_role(
AgentRole.COORDINATOR,
f"基于各专家意见和审查反馈，输出最终执行方案。\n\n方案：{consolidated}\n\n审查意见：{critique}"
)
return final
def _ask_role(self, role: AgentRole, query: str):
# 实际调用LLM的封装
config = self.pm.get_config(role)
# ... 调用逻辑
pass
def _ask_role_with_config(self, role: AgentRole, query: str, config: Dict):
# 带配置的调用
pass
3. Prompt模板继承与组合
class PromptTemplateInheritance:
"""支持继承的Prompt模板系统"""
def __init__(self):
self.base_templates = {
"professional": "你是专业领域的{specialty}专家。保持客观、准确、有帮助。",
"friendly": "你是用户的友好伙伴。语气温暖、耐心、鼓励性。",
"concise": "回答简洁明了，避免冗余。使用要点式输出。"
}
self.specialized_templates = {
"tech_support": {
"extends": "professional",
"addition": "优先提供可执行的解决方案，而非理论解释。",
"variables": {"specialty": "技术支持"}
},
"onboarding_helper": {
"extends": ["friendly", "concise"],
"addition": "引导用户完成新手流程，每步只给一个指令。",
"variables": {"specialty": "用户引导"}
}
}
def render(self, template_name: str, **extra_vars) -> str:
template = self.specialized_templates[template_name]
# 收集继承链
bases = template.get("extends", [])
if isinstance(bases, str):
bases = [bases]
# 组合Prompt
parts = []
for base in bases:
base_prompt = self.base_templates[base]
parts.append(base_prompt)
parts.append(template["addition"])
# 变量替换
full_prompt = "\n".join(parts)
variables = template.get("variables", {})
variables.update(extra_vars)
return full_prompt.format(**variables)
# 使用
renderer = PromptTemplateInheritance()
tech_prompt = renderer.render("tech_support")
# 结果：你是专业领域的技术支持专家。保持客观、准确、有帮助。优先提供可执行的解决方案，而非理论解释。
五、实战：一个完整的工程化Prompt系统
让我们把以上所有概念整合成一个生产级的Prompt管理系统：
import yaml
from pathlib import Path
from typing import Dict, Any, Optional
from jinja2 import Template
class ProductionPromptManager:
"""
生产级Prompt管理系统
特性：
- YAML配置管理
- 版本控制
- A/B测试支持
- 动态变量注入
- 多语言支持
"""
def __init__(self, config_path: str = "prompts/"):
self.config_path = Path(config_path)
self.prompts: Dict[str, Any] = {}
self.versions: Dict[str, str] = {}
self._load_prompts()
def _load_prompts(self):
"""从YAML文件加载Prompt配置"""
for file in self.config_path.glob("*.yaml"):
with open(file, 'r', encoding='utf-8') as f:
data = yaml.safe_load(f)
self.prompts.update(data.get('prompts', {}))
self.versions.update(data.get('versions', {}))
def get(
self,
prompt_id: str,
variables: Optional[Dict] = None,
version: Optional[str] = None,
context: Optional[Dict] = None
) -> str:
"""
获取并渲染Prompt
Args:
prompt_id: Prompt标识符
variables: 模板变量
version: 指定版本（用于A/B测试）
context: 动态上下文（用于条件逻辑）
"""
# 版本控制
active_version = version or self.versions.get(prompt_id, "latest")
prompt_def = self.prompts.get(prompt_id, {})
if active_version != "latest" and "versions" in prompt_def:
prompt_def = prompt_def["versions"].get(active_version, prompt_def)
# 获取基础模板
template_str = prompt_def.get("template", "")
# 条件渲染（基于context）
conditions = prompt_def.get("conditions", [])
for condition in conditions:
if self._eval_condition(condition["when"], context):
template_str += "\n" + condition["append"]
# Jinja2渲染
template = Template(template_str)
rendered = template.render(**(variables or {}))
return rendered
def _eval_condition(self, condition: str, context: Optional[Dict]) -> bool:
"""评估条件表达式"""
if not context:
return False
# 简化的条件评估，实际可用eval或安全解析器
try:
return eval(condition, {"__builtins__": {}}, context)
except:
return False
def list_prompts(self) -> Dict:
"""列出所有可用Prompt"""
return {
pid: {
"description": p.get("description", ""),
"current_version": self.versions.get(pid, "latest"),
"variables": p.get("variables", [])
}
for pid, p in self.prompts.items()
}
# 配置示例 (prompts/customer_service.yaml)
"""
prompts:
customer_service_bot:
description: "智能客服机器人主Prompt"
version: "2.1.0"
variables: ["user_tier", "product_line", "language"]
template: |
你是{{ product_line }}的专属客服助手。
用户等级：{{ user_tier }}
{% if user_tier == "VIP" %}
对VIP用户：优先处理，提供专属折扣权限，可直接升级至人工。
{% endif %}
【服务准则】
1. 使用{{ language }}回复
2. 首次响应时间 < 30秒
3. 复杂问题提供步骤清单
conditions:
- when: "context.get('is_weekend', False)"
append: "注意：当前为周末，非紧急技术问题建议工作日处理。"
- when: "context.get('user_tier') == 'enterprise'"
append: "企业级客户：可提及SLA保障和专属客户经理。"
versions:
"2.0.0": # 旧版本保留用于回滚
template: "..."
"""
# 使用示例
manager = ProductionPromptManager("./prompts")
# 普通调用
prompt_v1 = manager.get(
"customer_service_bot",
variables={
"user_tier": "VIP",
"product_line": "云服务",
"language": "中文"
},
context={"is_weekend": True}
)
# A/B测试：50%流量使用新版本
import random
version = "2.1.0-beta" if random.random() > 0.5 else "2.0.0"
prompt_ab = manager.get("customer_service_bot", version=version)
总结：Prompt工程化的三个层次
| 层次 | 特点 | 适用场景 |
|---|---|---|
| 静态Prompt | 固定模板，变量替换 | 确定性任务、标准化回复 |
| 动态Prompt | 上下文感知，条件渲染 | 个性化交互、多轮对话 |
| 智能Prompt | 多角色协作，缓存优化 | 复杂Agent系统、企业级应用 |
记住：好的Prompt不是写出来的，是迭代出来的。建议建立Prompt版本库，记录每次改动的效果数据（用户满意度、任务完成率、Token成本），用数据驱动优化。
下集预告：在下一篇《Agent状态管理与记忆系统》中，我们将探讨如何让AI记住"你上周说过喜欢川菜"，以及短期记忆和长期记忆的区别。敬请期待！
关注公众号【dev派】，发送 "agent" 获取全部源码和模板
