LLM Agent 开发岗位能力地图
基于 AI Agent 岗位 JD 提取的核心能力与技能要求
目录
职位概述
岗位描述（摘要）
设计和实现基于 LLM 的智能体核心架构，负责智能体平台的后端服务开发与优化，打造高性能、高可用的分布式系统。
核心职责
| 职责 |
具体内容 |
| 智能体架构设计 |
任务规划、对话管理、意图识别、流程工程 |
| 后端服务开发 |
高性能、高可用分布式系统 |
| RAG 系统优化 |
提升垂直领域专业表现和知识理解能力 |
| 多模态交互 |
基于 LangChain 等框架构建丰富用户体验 |
| 记忆管理系统 |
通过向量数据库优化长期记忆能力 |
| 多 Agent 协作 |
构建 Multi-Agent 协作系统，可扩展生态平台 |
技术栈总览
编程语言
| 语言 |
用途 |
重要性 |
| Python |
Agent 核心逻辑、LangChain/LLM 接口 |
⭐⭐⭐⭐⭐ |
| Golang |
高性能后端服务、分布式系统 |
⭐⭐⭐⭐ |
Agent 框架对比
| 框架 |
特点 |
适用场景 |
学习优先级 |
| LangChain |
生态最成熟，工具链丰富 |
通用 Agent 开发 |
⭐⭐⭐⭐⭐ |
| LlamaIndex |
数据框架，RAG 优化 |
知识检索增强 |
⭐⭐⭐⭐ |
| AutoGen |
微软出品，对话式 Agent |
多 Agent 对话 |
⭐⭐⭐ |
| CrewAI |
角色驱动，任务编排 |
团队协作 Agent |
⭐⭐⭐ |
| Dify |
开源平台，可视化 |
低代码 Agent 开发 |
⭐⭐⭐ |
| LangGraph |
图编排，状态机 |
复杂工作工作流 |
⭐⭐⭐⭐ |
| LangFlow |
可视化工作流设计 |
拖拽式工作流 |
⭐⭐ |
协议与通信
| 协议 |
用途 |
说明 |
| MCP |
Model Context Protocol |
Agent 与模型上下文通信标准 |
| HTTP/HTTPS |
RESTful API |
Agent 间通信、Client-Server |
| WebSocket |
实时双向通信 |
流式输出、实时交互 |
基础设施
| 类型 |
技术 |
用途 |
| 向量数据库 |
Milvus/Pinecone/Weaviate |
长期记忆、RAG 检索 |
| 消息队列 |
Kafka/RabbitMQ/Redis |
异步通信、任务队列 |
| 缓存 |
Redis |
热点缓存、会话管理 |
| 数据库 |
PostgreSQL/MongoDB |
元数据存储、日志 |
核心能力详解
1. 智能体核心架构设计
1.1 任务规划（Task Planning）
【核心概念】
任务规划是将用户请求分解为可执行的子任务序列。
【规划策略】
1. ReAct 模式（动态规划）
- 逐步探索
- 实时调整
- 适合探索性任务
2. Plan & Execute 模式（静态规划）
- 一次性规划
- DAG 表示
- 可并行执行
3. 混合模式
- 先粗规划
- 执行中动态调整
# 任务规划器实现
from typing import List, Dict
from dataclasses import dataclass
from enum import Enum
class TaskStatus(Enum):
PENDING = "pending"
IN_PROGRESS = "in_progress"
COMPLETED = "completed"
FAILED = "failed"
@dataclass
class Task:
id: str
description: str
dependencies: List[str] # 依赖的任务ID
required_capabilities: List[str] # 所需能力
status: TaskStatus = TaskStatus.PENDING
result: str = None
@dataclass
class Plan:
tasks: List[Task]
reasoning: str # 规划思路
class TaskPlanner:
def __init__(self, llm):
self.llm = llm
def plan(self, user_request: str) -> Plan:
"""生成任务计划"""
prompt = f"""
分析以下用户请求，将其分解为可执行的子任务序列：
用户请求：{user_request}
请以 JSON 格式返回：
{{
"reasoning": "你的规划思路",
"tasks": [
{{
"id": "task-1",
"description": "任务描述",
"dependencies": [],
"required_capabilities": ["能力1", "能力2"]
}}
]
}}
要求：
1. 明确任务依赖关系
2. 确保任务可执行
3. 无循环依赖
"""
response = self.llm.generate(prompt)
return self._parse_plan(response)
1.2 对话管理（Dialog Management）
【核心组件】
1. 会话管理
- 会话生命周期
- 上下文维护
- 状态追踪
2. 意图识别
- 用户意图分类
- 槽位提取
- 意图确认
3. 多轮对话
- 上下文传递
- 指令跟随
- 状态更新
from typing import Dict, List
from datetime import datetime
@dataclass
class Session:
id: str
user_id: str
messages: List[Dict]
metadata: Dict
created_at: datetime
updated_at: datetime
class DialogManager:
def __init__(self, storage):
self.storage = storage
self.intent_classifier = IntentClassifier()
def create_session(self, user_id: str) -> Session:
"""创建会话"""
session = Session(
id=self._generate_id(),
user_id=user_id,
messages=[],
metadata={},
created_at=datetime.now(),
updated_at=datetime.now()
)
self.storage.save(session)
return session
def process_message(self, session_id: str, message: str) -> str:
"""处理消息"""
# 1. 加载会话
session = self.storage.load(session_id)
# 2. 识别意图
intent = self.intent_classifier.classify(message)
# 3. 根据意图处理
response = self._handle_intent(session, intent, message)
# 4. 更新会话
session.messages.append({"role": "user", "content": message})
session.messages.append({"role": "assistant", "content": response})
session.updated_at = datetime.now()
self.storage.save(session)
return response
1.3 意图识别（Intent Recognition）
【常见意图类型】
- 查询（Query）：信息检索
- 操作（Action）：执行某个操作
- 确认（Confirm）：确认操作
- 否定（Deny）：拒绝操作
- 闲聊（Chat）：自由对话
- 退出（Exit）：结束对话
【识别方法】
1. 规则匹配
2. 分类模型
3. LLM 分类
class IntentClassifier:
INTENTS = ["query", "action", "confirm", "deny", "chat", "exit"]
def __init__(self, llm):
self.llm = llm
def classify(self, message: str) -> Dict:
"""识别意图和槽位"""
prompt = f"""
分析以下用户消息，识别意图和槽位：
用户消息：{message}
可用意图：
- query: 信息查询（如：查询天气、查订单）
- action: 执行操作（如：创建任务、发送邮件）
- confirm: 确认操作（如：是的、确认）
- deny: 否定操作（如：不、取消）
- chat: 闲聊（如：你好、说说看）
- exit: 退出对话（如：再见、结束）
请以 JSON 格式返回：
{{
"intent": "意图",
"confidence": 0.95,
"slots": {{"key": "value"}}
}}
"""
response = self.llm.generate(prompt)
return json.loads(response)
1.4 流程工程（Flow Engineering）
【流程类型】
1. 顺序流程
2. 条件分支
3. 循环流程
4. 并行流程
5. 子流程调用
【可视化工具】
- LangGraph：状态机可视化
- LangFlow：拖拽式流程设计
from langgraph.graph import StateGraph, END
from typing import TypedDict
class FlowState(TypedDict):
input: str
intent: str
context: dict
response: str
def intent_node(state: FlowState):
"""意图识别节点"""
intent = intent_classifier.classify(state["input"])
return {"intent": intent["intent"]}
def route_intent(state: FlowState) -> str:
"""路由决策"""
if state["intent"] == "query":
return "query_handler"
elif state["intent"] == "action":
return "action_handler"
else:
return "default_handler"
def query_handler(state: FlowState):
"""查询处理"""
result = rag_engine.query(state["input"])
return {"response": result.answer}
def action_handler(state: FlowState):
"""操作处理"""
result = agent_executor.execute(state["input"])
return {"response": result}
# 构建流程图
workflow = StateGraph(FlowState)
workflow.add_node("intent", intent_node)
workflow.add_node("query_handler", query_handler)
workflow.add_node("action_handler", action_handler)
workflow.set_entry_point("intent")
workflow.add_conditional_edges("intent", route_intent)
workflow.add_edge("query_handler", END)
workflow.add_edge("action_handler", END)
app = workflow.compile()
2. 后端服务开发（Go）
2.1 高性能 API 服务
package main
import (
"context"
"encoding/json"
"net/http"
"time"
)
// AgentService Agent 服务接口
type AgentService struct {
llmClient *LLMClient
vectorStore *VectorStore
cache *CacheClient
}
// QueryRequest 查询请求
type QueryRequest struct {
Query string `json:"query"`
Options map[string]string `json:"options,omitempty"`
}
// QueryResponse 查询响应
type QueryResponse struct {
Answer string `json:"answer"`
Sources []string `json:"sources,omitempty"`
Latency int64 `json:"latency_ms"`
}
// HandleQuery 处理查询请求
func (s *AgentService) HandleQuery(w http.ResponseWriter, r *http.Request) {
start := time.Now()
// 1. 解析请求
var req QueryRequest
if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
// 2. 检查缓存
cacheKey := generateCacheKey(req.Query)
if cached, found := s.cache.Get(cacheKey); found {
writeResponse(w, cached, start)
return
}
// 3. 执行 RAG 查询
ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
defer cancel()
result, err := s.ExecuteQuery(ctx, req.Query)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
// 4. 缓存结果
s.cache.Set(cacheKey, result, 5*time.Minute)
// 5. 返回响应
writeResponse(w, result, start)
}
// ExecuteQuery 执行查询（异步执行）
func (s *AgentService) ExecuteQuery(ctx context.Context, query string) (*QueryResponse, error) {
// 并行执行检索和意图分析
type result struct {
documents []Document
intent string
}
resultChan := make(chan result, 2)
errChan := make(chan error, 2)
// 并行检索
go func() {
docs, err := s.vectorStore.Search(ctx, query, 5)
if err != nil {
errChan <- err
return
}
resultChan <- result{documents: docs}
}()
// 并行意图分析
go func() {
intent, err := s.llmClient.ClassifyIntent(ctx, query)
if err != nil {
errChan <- err
return
}
resultChan <- result{intent: intent}
}()
// 收集结果
var resp result
for i := 0; i < 2; i++ {
select {
case r := <-resultChan:
if r.documents != nil {
resp.documents = r.documents
}
if r.intent != "" {
resp.intent = r.intent
}
case err := <-errChan:
return nil, err
case <-ctx.Done():
return nil, ctx.Err()
}
}
// 生成答案
answer, err := s.llmClient.Generate(ctx, query, resp.documents)
if err != nil {
return nil, err
}
return &QueryResponse{
Answer: answer,
Sources: extractSources(resp.documents),
}, nil
}
2.2 分布式架构
【架构层次】
┌─────────────────────────────────────┐
│ API Gateway │ ← Nginx/Kong
├─────────────────────────────────────┤
│ Load Balancer │ ← 负载均衡
├─────────────────────────────────────┤
│ ┌───────┬───────┬───────┐ │
│ │Service│Service│Service│ ... │ ← Go 微服务
│ │ 1 │ 2 │ 3 │ │
│ └───────┴───────┴───────┘ │
├─────────────────────────────────────┤
│ ┌───────┬───────┬───────┐ │
│ │ LLM │Vector │Message│ │ ← 基础服务
│ │Service│ Store │ Queue │ │
│ └───────┴───────┴───────┘ │
├─────────────────────────────────────┤
│ ┌───────┬───────┬───────┐ │
│ │ Redis │ DB │ File │ │ ← 存储
│ └───────┴───────┴───────┘ │
└─────────────────────────────────────┘
2.3 高可用设计
// Retry 重试机制
func Retry(attempts int, delay time.Duration, fn func() error) error {
var err error
for i := 0; i < attempts; i++ {
if err = fn(); err == nil {
return nil
}
if i < attempts-1 {
time.Sleep(delay)
}
}
return err
}
// CircuitBreaker 熔断器
type CircuitBreaker struct {
maxFailures int
resetTimeout time.Duration
failures int
lastFailTime time.Time
state string // "closed", "open", "half-open"
}
func (cb *CircuitBreaker) Call(fn func() error) error {
if cb.state == "open" {
if time.Since(cb.lastFailTime) < cb.resetTimeout {
return errors.New("circuit breaker is open")
}
cb.state = "half-open"
}
err := fn()
if err != nil {
cb.failures++
cb.lastFailTime = time.Now()
if cb.failures >= cb.maxFailures {
cb.state = "open"
}
return err
}
cb.failures = 0
cb.state = "closed"
return nil
}
// RateLimiter 限流器
type RateLimiter struct {
requests map[string][]time.Time
limit int
window time.Duration
}
func (rl *RateLimiter) Allow(key string) bool {
now := time.Now()
windowStart := now.Add(-rl.window)
requests := rl.requests[key]
var valid []time.Time
for _, t := range requests {
if t.After(windowStart) {
valid = append(valid, t)
}
}
if len(valid) >= rl.limit {
return false
}
valid = append(valid, now)
rl.requests[key] = valid
return true
}
3. RAG 系统开发
3.1 RAG 优化策略
【检索优化】
1. 查询扩展
- 同义词扩展
- LLM 生成相关查询
- 拆分复合词
2. 混合检索
- 向量检索 + BM25
- 加权融合
3. Re-ranking
- Cross-encoder
- LLM 重排
【上下文优化】
1. 智能截断
- 按分数排序
- Token 精确估算
2. 上下文压缩
- 摘要压缩
- 关键句提取
3.2 LlamaIndex 集成
from llama_index import VectorStoreIndex, ServiceContext
from llama_index.node_parser import SentenceSplitter
from llama_index.embeddings import OpenAIEmbedding
from llama_index.vector_stores import MilvusVectorStore
# 初始化向量存储
vector_store = MilvusVectorStore(
host="localhost",
port=19530,
collection_name="documents"
)
# 配置嵌入模型
embed_model = OpenAIEmbedding()
# 配置节点解析器
node_parser = SentenceSplitter(
chunk_size=512,
chunk_overlap=50
)
# 创建服务上下文
service_context = ServiceContext.from_defaults(
embed_model=embed_model,
node_parser=node_parser
)
# 创建索引
index = VectorStoreIndex.from_documents(
documents=documents,
vector_store=vector_store,
service_context=service_context
)
# 创建查询引擎
query_engine = index.as_query_engine(
similarity_top_k=10,
retriever_mode="hybrid" # 混合检索
)
# 执行查询
response = query_engine.query("Python 并发编程的最佳实践？")
4. 记忆管理系统
4.1 记忆类型
【短期记忆】
- 存储：内存/Redis
- 用途：对话历史
- 容量：最近 N 条
- 策略：FIFO/LRU
【长期记忆】
- 存储：向量数据库
- 用途：历史信息、知识库
- 检索：语义搜索
- 索引：向量索引
【情景记忆】
- 存储：共享变量
- 用途：当前任务上下文
- 生命周期：任务级
【结构化记忆】
- 存储：关系数据库
- 用途：用户偏好、会话状态
- 查询：结构化查询
4.2 记忆实现
from typing import List, Dict, Optional
from dataclasses import dataclass
from datetime import datetime
@dataclass
class Memory:
"""记忆条目"""
id: str
content: str
embedding: List[float]
metadata: Dict
timestamp: datetime
class MemoryManager:
"""记忆管理器"""
def __init__(self, vector_store, llm):
self.vector_store = vector_store
self.llm = llm
def add_memory(self, content: str, metadata: Dict) -> str:
"""添加记忆"""
# 生成嵌入
embedding = self.llm.embed(content)
# 创建记忆
memory = Memory(
id=self._generate_id(),
content=content,
embedding=embedding,
metadata=metadata,
timestamp=datetime.now()
)
# 存储到向量库
self.vector_store.add(memory)
return memory.id
def recall(self, query: str, top k: int = 5) -> List[Memory]:
"""回忆相关记忆"""
# 嵌入查询
query_embedding = self.llm.embed(query)
# 向量检索
memories = self.vector_store.search(
query_vector=query_embedding,
top_k=top_k
)
return memories
def summarize(self, memories: List[Memory]) -> str:
"""总结记忆"""
contents = [m.content for m in memories]
prompt = f"""
请总结以下记忆内容：
{chr(10).join(contents)}
请提供一个简洁的总结。
"""
return self.llm.generate(prompt)
def compress(self, threshold: int = 100):
"""压缩记忆"""
# 获取所有记忆
all_memories = self.vector_store.get_all()
# 如果超过阈值，压缩旧记忆
if len(all_memories) > threshold:
# 分批压缩
for i in range(0, len(all_memories), threshold):
batch = all_memories[i:i+threshold]
summary = self.summarize(batch)
# 用摘要替换
self._replace_with_summary(batch, summary)
5. Multi-Agent 协作系统
5.1 Agent 通信机制
【通信方式】
1. 同步通信（直接调用）
- 简单场景
- 低延迟
2. 异步通信（消息队列）
- 解耦 Agent
- 高可靠
3. 共享内存（共享状态）
- 高频交互
- 低延迟
5.2 基于 AutoGen 实现
from autogen import AssistantAgent, UserProxyAgent, GroupChat, GroupChatManager
# 配置 LLM
config_list = [{
"model": "gpt-4",
"api_key": "your-api-key"
}]
# 创建专业 Agents
researcher = AssistantAgent(
name="Researcher",
llm_config={"config_list": config_list},
system_message="""你是研究专家，擅长信息搜集和分析。
你的任务是：
1. 搜索相关信息
2. 分析数据
3. 提供见解"""
)
analyst = AssistantAgent(
name="Analyst",
llm_config={"config_list": config_list},
system_message="""你是分析专家，擅长数据分析和报告生成。
你的任务是：
1. 分析研究结果
2. 生成报告
3. 提供建议"""
)
writer = AssistantAgent(
name="Writer",
llm_config={"config_list": config_list},
system_message="""你是写作专家，擅长内容整理和总结。
你的任务是：
1. 整理各方意见
2. 撰写最终报告
3. 确保条理清晰"""
)
# 创建用户代理
user_proxy = UserProxyAgent(
name="User",
human_input_mode="NEVER",
max_consecutive_auto_reply=10
)
# 创建群聊
groupchat = GroupChat(
agents=[researcher, analyst, writer],
messages=[],
max_round=10
)
# 创建群聊管理器
manager = GroupChatManager(
groupchat=groupchat,
name="Manager",
llm_config={"config_list": config_list},
system_message="""你是任务协调员，负责：
1. 接收用户任务
2. 分配给合适的专家
3. 协调各方协作
4. 汇总最终结果"""
)
# 发起任务
result = user_proxy.initiate_chat(
manager,
message="请帮我研究 AI Agent 技术趋势并写一份报告"
)
print(result)
6. 多模态交互
6.1 支持的模态
【文本】
- 基础对话
- 文档处理
【图像】
- 图像理解
- 图像生成
【语音】
- 语音识别（ASR）
- 语音合成（TTS）
【视频】
- 视频理解
- 关键帧提取
6.2 多模态 Agent 实现
class MultimodalAgent:
def __init__(self, llm, vision_model):
self.llm = llm
self.vision_model = vision_model
def process_image(self, image: Image, query: str) -> str:
"""处理图像查询"""
# 1. 图像理解
image_description = self.vision_model.describe(image)
# 2. 结合文本查询生成答案
prompt = f"""
图像描述：
{image_description}
用户问题：
{query}
请基于图像信息回答问题。
"""
return self.llm.generate(prompt)
def generate_image(self, text_prompt: str) -> Image:
"""生成图像"""
return self.vision_model.generate(text_prompt)
def process_video(self, video: Video, query: str) -> str:
"""处理视频查询"""
# 1. 提取关键帧
keyframes = self._extract_keyframes(video)
# 2. 理解关键帧
descriptions = [
self.vision_model.describe(frame)
for frame in keyframes
]
# 3. 生成答案
prompt = f"""
视频关键帧描述：
{chr(10).join(descriptions)}
用户问题：
{query}
请基于视频内容回答问题。
"""
return self.llm.generate(prompt)
框架与工具
LangChain 核心组件
| 组件 |
用途 |
示例 |
| LLM |
大模型接口 |
ChatOpenAI, ChatAnthropic |
| Chain |
处理链 |
SequentialChain, RouterChain |
| Agent |
智能体 |
create_openai_functions_agent |
| Tool |
工具调用 |
Tool, StructuredTool |
| Memory |
记忆管理 |
ConversationBufferMemory |
| VectorStore |
向量存储 |
FAISS, Chroma |
| Retriever |
检索器 |
VectorStoreRetriever |
| PromptTemplate |
提示模板 |
ChatPromptTemplate |
LlamaIndex 核心组件
| 组件 |
用途 |
示例 |
| Document |
文档表示 |
Document |
| NodeParser |
节点解析 |
SentenceSplitter |
| VectorStoreIndex |
向量索引 |
VectorStoreIndex |
| QueryEngine |
查询引擎 |
as_query_engine() |
| Retriever |
检索器 |
VectorIndexRetriever |
| ResponseSynthesizer |
响应合成 |
get_response_synthesizer() |
工程实践
部署架构
【部署方案】
1. 容器化部署
- Docker 容器
- Kubernetes 编排
- Helm Chart 管理
2. 服务治理
- 服务注册发现（Consul/Etcd）
- 服务网格（Istio/Linkerd）
- 配置中心
3. 可观测性
- 日志（ELK/Loki）
- 监控（Prometheus/Grafana）
- 链路追踪（Jaeger/Zipkin）
4. 质量保障
- 健康检查
- 熔断降级
- 限流熔断
监控指标
【核心指标】
1. 性能指标
- 响应时间（P50/P95/P99）
- 吞吐量（QPS）
- 错误率
2. 资源指标
- CPU 使用率
- 内存使用率
- 磁盘 I/O
3. 业务指标
- Agent 调用次数
- 工具调用成功率
- RAG 检索准确率
面试高频问法
Q1: 如何设计一个可扩展的 Agent 系统？
【标准回答】
设计原则：
1. 模块化设计
- Agent 独立封装
- 工具可插拔
- 记忆可替换
2. 接口标准化
- 统一的 Agent 接口
- 标准的工具定义
- 一致的通信协议
3. 水平扩展
- 无状态设计
- 分布式部署
- 负载均衡
4. 可观测性
- 完善的日志
- 指标监控
- 链路追踪
架构层次：
- API 层：接口网关
- 编排层：任务编排
- Agent 层：专业 Agent
- 服务层：LLM、存储
- 基础层：基础设施
Q2: RAG 系统如何提升检索准确率？
【标准回答】
优化策略：
1. 查询层
- 查询扩展（同义词、LLM 生成）
- 查询改写（明确意图）
2. 检索层
- 混合检索（向量 + BM25）
- 多模型检索（精确 + 快速）
- 元数据过滤
3. 重排层
- Cross-encoder
- LLM rerank
- 规则重排
4. 数据层
- 更好的嵌入模型
- 优化的切分策略
- 丰富的元数据
Q3: Go 和 Python 在 Agent 开发中的分工？
【标准回答】
Go 负责：
- 高性能 API 服务
- 并发任务调度
- 分布式协调
- 基础设施服务
Python 负责：
- Agent 核心逻辑
- LLM 调用
- 数据处理
- 模型推理
协作方式：
- gRPC/HTTP 通信
- 消息队列异步
- 共享存储
Q4: 如何实现 Agent 长期记忆？
【标准回答】
三层架构：
1. 短期记忆
- 存储：Redis
- 内容：最近对话
- 访问：直接读取
2. 长期记忆
- 存储：向量数据库
- 内容：历史信息
- 访问：语义检索
3. 结构化记忆
- 存储：关系数据库
- 内容：用户偏好
- 访问：SQL 查询
检索策略：
- 合并短期和长期
- 去重
- 按相关性排序
学习路径
阶段一：基础掌握（2-3 周）
目标：掌握 Agent 基础概念和框架
任务：
□ 了解 ReAct、Plan & Execute 模式
□ 学习 LangChain 基础用法
□ 实现简单的 RAG Agent
□ 掌握 Tool Calling 机制
可交付：
- ReAct Agent Demo
- RAG 查询 Demo
阶段二：框架深入（3-4 周）
目标：熟练使用主流框架
任务：
□ LangChain 深入学习
□ LlamaIndex RAG 优化
□ AutoGen 多 Agent
□ CrewAI 团队协作
可交付：
- 复杂 RAG 系统
- 多 Agent 协作 Demo
阶段三：工程实践（4-5 周）
目标：构建生产级系统
任务：
□ Go 后端服务开发
□ 分布式架构设计
□ 高可用实现
□ 监控告警搭建
可交付：
- 完整 Agent 平台
- 部署文档
阶段四：优化提升（持续）
目标：持续优化和迭代
任务：
□ 性能优化
□ 成本优化
□ 效果评估
□ 用户反馈收集
可交付：
- 性能优化报告
- 成本分析报告
文档版本: 1.0
最后更新: 2026-01-21
