Prompt 与 RAG 系统设计要点

Prompt 写得烂，再好的模型也救不了你；RAG 建得乱，知识库就是垃圾场。作为 PM，你不需要亲自调 Prompt，但你必须能判断一个 Prompt 设计是否合理、一套 RAG 架构是否值得投入。

Prompt 结构的 PM 视角

Prompt 设计核心原则

PM 需要知道什么样的 Prompt 是结构化的：

何时需要 RAG

不需要 RAG 的场景： - 任务完全基于通用知识（写文案、改语气、分类） - 知识量少于 10 个文档且不会更新 - 对延迟极度敏感（RAG 会增加 200-800ms）

必须上 RAG 的场景： - 知识库超过模型上下文窗口 - 知识需要实时更新（价格、政策、库存） - 需要溯源引用（法律、医疗、金融合规） - 用户问题高度个性化（用户历史、账户信息）

RAG 设计关键决策点

Python 示例：RAG 系统设计评估器

"""
RAG 系统设计评估器
PM 视角：评估一套 RAG 方案的合理性与风险点
"""
from dataclasses import dataclass, field
from typing import List, Dict, Tuple
import json
@dataclass
class RAGDesignConfig:
"""RAG 设计配置"""
name: str
# 知识库配置
doc_count: int              # 文档数量
update_frequency: str       # 更新频率: daily/weekly/monthly/static
avg_doc_length: int         # 平均文档字数
# 切分策略
chunk_size: int             # 切分大小（字符数）
chunk_overlap: int          # 重叠字符数
# 检索配置
retrieval_type: str         # vector/keyword/hybrid
top_k: int                  # 召回数量
use_reranker: bool          # 是否使用重排序
# 业务配置
latency_requirement_ms: int # 延迟要求（毫秒）
requires_citation: bool     # 是否需要引用溯源
query_per_day: int          # 日均查询量
@dataclass
class EvaluationResult:
"""评估结果"""
config_name: str
dimension_scores: Dict[str, int] = field(default_factory=dict)
issues: List[str] = field(default_factory=list)
suggestions: List[str] = field(default_factory=list)
overall_score: int = 0
def evaluate_chunk_strategy(config: RAGDesignConfig) -> Tuple[int, List[str], List[str]]:
"""评估切分策略"""
score = 100
issues = []
suggestions = []
# 检查 chunk size 合理性
if config.chunk_size < 100:
score -= 30
issues.append("切分粒度过细（<100字），语义碎片化风险高")
suggestions.append("建议 chunk_size 调整为 300-600 字")
elif config.chunk_size > 2000:
score -= 20
issues.append("切分粒度过粗（>2000字），检索精度下降")
suggestions.append("建议 chunk_size 调整为 500-1000 字")
else:
suggestions.append(f"切分粒度 {config.chunk_size} 字，处于合理区间")
# 检查重叠比例
overlap_ratio = config.chunk_overlap / config.chunk_size
if overlap_ratio < 0.05:
score -= 15
issues.append("重叠率过低，跨块信息可能丢失")
elif overlap_ratio > 0.4:
score -= 10
issues.append("重叠率过高（>40%），存储成本增加且检索噪声多")
else:
suggestions.append(f"重叠率 {overlap_ratio:.0%}，配置合理")
return score, issues, suggestions
def evaluate_retrieval_strategy(config: RAGDesignConfig) -> Tuple[int, List[str], List[str]]:
"""评估检索策略"""
score = 100
issues = []
suggestions = []
# 检索类型与场景匹配
if config.retrieval_type == "vector":
if config.doc_count < 100:
score -= 20
issues.append("文档量少（<100篇）时向量检索成本偏高，关键词检索可能更高效")
elif config.retrieval_type == "keyword":
score -= 15
issues.append("纯关键词检索对语义理解弱，推荐升级为混合检索")
suggestions.append("建议使用 hybrid 检索（向量 + BM25）")
elif config.retrieval_type == "hybrid":
suggestions.append("混合检索是当前最佳实践，兼顾语义与精确匹配")
# 召回数量评估
if config.top_k > 10:
score -= 20
issues.append(f"top_k={config.top_k} 过大，上下文注入会稀释相关性且增加 token 成本")
suggestions.append("建议 top_k 控制在 3-7 之间")
elif config.top_k < 3:
score -= 10
issues.append(f"top_k={config.top_k} 过小，召回率不足")
return score, issues, suggestions
def evaluate_performance(config: RAGDesignConfig) -> Tuple[int, List[str], List[str]]:
"""评估性能配置"""
score = 100
issues = []
suggestions = []
# 估算 RAG 延迟
base_latency = 300  # 向量检索基础延迟 ms
if config.use_reranker:
base_latency += 250
suggestions.append("使用了 Reranker，预计额外增加 200-300ms 延迟")
if base_latency > config.latency_requirement_ms * 0.6:
score -= 25
issues.append(
f"RAG 预估延迟 {base_latency}ms 可能超出延迟预算 "
f"（要求 {config.latency_requirement_ms}ms）"
)
suggestions.append("考虑引入查询缓存或降低 top_k")
# 高并发成本
if config.query_per_day > 100000:
suggestions.append(
f"日均 {config.query_per_day:,} 次查询，"
"强烈建议上缓存层，可降低 40-60% 向量检索成本"
)
return score, issues, suggestions
def evaluate_rag_design(config: RAGDesignConfig) -> EvaluationResult:
"""综合评估 RAG 设计方案"""
result = EvaluationResult(config_name=config.name)
# 分维度评估
chunk_score, chunk_issues, chunk_suggestions = evaluate_chunk_strategy(config)
retrieval_score, retrieval_issues, retrieval_suggestions = evaluate_retrieval_strategy(config)
perf_score, perf_issues, perf_suggestions = evaluate_performance(config)
result.dimension_scores = {
"切分策略": chunk_score,
"检索策略": retrieval_score,
"性能配置": perf_score,
}
result.issues = chunk_issues + retrieval_issues + perf_issues
result.suggestions = chunk_suggestions + retrieval_suggestions + perf_suggestions
# 综合评分（加权平均）
result.overall_score = int(
chunk_score * 0.35 + retrieval_score * 0.40 + perf_score * 0.25
)
return result
def print_report(result: EvaluationResult):
"""打印评估报告"""
print(f"\n{'='*55}")
print(f"  RAG 设计评估报告：{result.config_name}")
print(f"{'='*55}")
print(f"综合评分：{result.overall_score}/100")
print("\n各维度得分：")
for dim, score in result.dimension_scores.items():
bar = "█" * (score // 10) + "░" * (10 - score // 10)
print(f"  {dim:<10} {bar} {score}")
if result.issues:
print(f"\n发现 {len(result.issues)} 个问题：")
for i, issue in enumerate(result.issues, 1):
print(f"  [{i}] ⚠ {issue}")
print("\n优化建议：")
for suggestion in result.suggestions:
print(f"  → {suggestion}")
grade = "优秀" if result.overall_score >= 85 else \
"良好" if result.overall_score >= 70 else \
"需优化" if result.overall_score >= 55 else "风险较高"
print(f"\n整体判断：{grade}")
print(f"{'='*55}")
# ── 演示 ──────────────────────────────────────────────
if __name__ == "__main__":
# 方案 A：一个配置较差的设计
config_a = RAGDesignConfig(
name="方案A（初版设计）",
doc_count=5000,
update_frequency="daily",
avg_doc_length=2000,
chunk_size=80,          # 太细
chunk_overlap=5,        # 重叠太少
retrieval_type="keyword", # 纯关键词
top_k=15,               # 太多
use_reranker=False,
latency_requirement_ms=500,
requires_citation=True,
query_per_day=200000,
)
# 方案 B：优化后的设计
config_b = RAGDesignConfig(
name="方案B（优化版）",
doc_count=5000,
update_frequency="daily",
avg_doc_length=2000,
chunk_size=400,         # 合理
chunk_overlap=60,       # ~15% 重叠
retrieval_type="hybrid", # 混合检索
top_k=5,                # 合理
use_reranker=True,
latency_requirement_ms=800,
requires_citation=True,
query_per_day=200000,
)
for cfg in [config_a, config_b]:
result = evaluate_rag_design(cfg)
print_report(result)

本章 checklist

• 在要求 AI 工程师设计 RAG 之前，先确认知识库文档是否已完成清洗和结构化
• 评审 Prompt 时，检查是否包含 Role / Task / Constraint / Format 四要素
• 对每个 RAG 方案，明确提出延迟预算要求（如不超过 600ms）
• 当知识更新频率超过每周一次时，要求在设计中说明知识库同步机制
• 要求 AI 工程师给出"无 RAG 召回结果时"的兜底行为设计

本章小结

• Prompt 结构的五要素（Role/Task/Constraint/Format/Few-shot）是 PM 评审 AI 方案的基础框架，不必会写，但必须会看
• RAG 的核心决策是切分粒度与检索策略，切分太细导致语义碎片，切分太粗导致噪声；混合检索（向量+关键词）是当前实践中最稳健的选择
• PM 对 RAG 的最大贡献是明确业务约束：延迟上限、溯源要求、更新频率，这三个约束直接决定 RAG 架构选型

下一节：03-Workflow与Agent的产品设计 — 从确定性流程到自主 Agent，PM 如何判断边界并设计可降级的产品