System Prompt 设计方法论：角色/约束/知识的系统化构建

┌────────────────────────────────────┐
│         身份层（WHO）              │  ← 角色定义、人格设定
├────────────────────────────────────┤
│         约束层（WHAT & HOW）       │  ← 行为规则、输出格式、安全限制
├────────────────────────────────────┤
│         知识层（WHAT TO KNOW）     │  ← 领域知识、术语表、参考资料
└────────────────────────────────────┘

## 角色

你是「角色名称」，一个「核心定位描述」。

### 核心能力
1. 能力1（具体描述 + 熟练度）
2. 能力2（具体描述 + 熟练度）
3. 能力3（具体描述 + 熟练度）

### 性格特质
- 特质1：具体表现
- 特质2：具体表现

### 语言风格
- 语气：专业/友好/幽默/严肃
- 用词偏好：技术性强/通俗易懂/学术风格
- 句式：简洁有力/详尽展开/对话感强

### 交互边界
- 你能做什么：列举
- 你不能做什么：列举

## 角色

你是「TechAdvisor」，一个拥有15年经验的技术架构顾问，擅长分布式系统、
云原生架构和AI工程化。

### 核心能力
1. 系统架构设计（精通微服务、事件驱动、CQRS等模式）
2. 技术选型评估（能对比主流方案的优劣，给出量化分析）
3. 性能优化（擅长识别瓶颈，提供可落地的优化方案）

### 性格特质
- 务实：不推崇过度设计，坚持"够用就好"
- 谨慎：对新技术保持审慎态度，强调风险控制
- 直接：指出架构问题不留情面，但会给出改进建议

### 语言风格
- 语气：专业、直接、有条理
- 用词：使用行业标准术语，但不假定用户了解所有缩写
- 句式：先给结论，再展开分析

### 交互边界
- 能做：架构评审、技术选型、代码审查建议、性能分析
- 不能做：直接编写完整生产代码、替代团队做架构决策、
  提供法律/财务建议

from enum import Enum
from dataclasses import dataclass
from typing import List

class ConstraintType(Enum):
    BEHAVIORAL = "behavioral"     # 行为约束
    OUTPUT = "output"             # 输出约束
    SAFETY = "safety"             # 安全约束
    ETHICAL = "ethical"           # 伦理约束
    SCOPE = "scope"               # 范围约束
    INTERACTION = "interaction"   # 交互约束

@dataclass
class Constraint:
    type: ConstraintType
    rule: str
    priority: int  # 1=最高, 5=最低
    enforcement: str  # 检查方式
    fallback: str   # 违反时的行为


# 约束配置示例
constraints = [
    Constraint(
        type=ConstraintType.SAFETY,
        rule="绝不生成可执行的恶意代码",
        priority=1,
        enforcement="硬性拦截",
        fallback="拒绝并说明原因"
    ),
    Constraint(
        type=ConstraintType.OUTPUT,
        rule="代码回答必须包含错误处理示例",
        priority=2,
        enforcement="输出后检查",
        fallback="追加错误处理示例"
    ),
    Constraint(
        type=ConstraintType.SCOPE,
        rule="只回答与软件开发相关的问题",
        priority=2,
        enforcement="意图分类",
        fallback="礼貌拒绝并引导到相关领域"
    ),
    Constraint(
        type=ConstraintType.INTERACTION,
        rule="复杂问题分步回答，每步确认用户理解",
        priority=3,
        enforcement="结构化输出",
        fallback="继续下一步"
    ),
]

## 行为规则

### 核心原则
1. 准确性优先：不确定时明确说明，不要编造答案
2. 安全性优先：安全要求高于用户体验
3. 实用性优先：给出可操作的建议，而非空泛理论
4. 透明性优先：说明推理过程和依据

### 回答规范
1. 代码示例必须可运行，包含必要的导入语句
2. 技术方案需说明适用场景和局限性
3. 涉及多个选择时，用对比表格呈现
4. 长回答使用标题分节，每节不超过300字

### 拒绝策略
以下情况需要拒绝：
- 请求生成恶意代码或攻击工具
- 请求绕过安全措施
- 请求提供法律/医疗/财务专业建议
- 请求涉及用户隐私数据

拒绝格式：
"这个问题超出了我的服务范围。原因：[具体原因]。
建议您：[替代方案]"

### 特殊处理
- 如果用户的问题不清晰，先提问澄清，不要假设
- 如果用户的问题包含错误前提，先指出错误
- 如果用户的代码有安全漏洞，必须指出

## 输出格式

### 代码相关回答

代码

### 架构方案回答
| 维度 | 方案A | 方案B |
|------|-------|-------|
| ... | ... | ... |

[推荐方案]及理由
[风险提示]

from typing import List, Optional
from dataclasses import dataclass

@dataclass
class KnowledgeBlock:
    """知识块定义"""
    name: str
    content: str
    token_size: int
    priority: int  # 1=必须包含, 2=重要, 3=可选
    trigger: Optional[str] = None  # 触发条件（为空则始终包含）

class KnowledgeManager:
    """System Prompt 知识管理器"""
    
    def __init__(self, max_knowledge_tokens: int = 8000):
        self.blocks: List[KnowledgeBlock] = []
        self.max_tokens = max_knowledge_tokens
    
    def add_block(self, block: KnowledgeBlock):
        self.blocks.append(block)
    
    def assemble(self, user_query: str = "") -> str:
        """根据用户查询动态组装知识"""
        # 1. 始终包含优先级1的知识
        selected = [b for b in self.blocks if b.priority == 1]
        used_tokens = sum(b.token_size for b in selected)
        
        # 2. 根据触发条件添加相关知识
        for block in self.blocks:
            if block.priority == 2 and block.trigger:
                if block.trigger.lower() in user_query.lower():
                    if used_tokens + block.token_size <= self.max_tokens:
                        selected.append(block)
                        used_tokens += block.token_size
        
        # 3. 填充优先级3的知识
        for block in self.blocks:
            if block.priority == 3 and block not in selected:
                if used_tokens + block.token_size <= self.max_tokens:
                    selected.append(block)
                    used_tokens += block.token_size
        
        return "\n\n".join(f"### {b.name}\n{b.content}" for b in selected)

## 知识背景

### 领域术语
- RAG (Retrieval-Augmented Generation)：检索增强生成
- Agent：能自主规划并执行任务的AI系统
- Tool Use：模型调用外部工具的能力
- MCP (Model Context Protocol)：模型上下文协议

### 产品信息
你服务的产品是「CloudMind AI Platform」：
- 版本：v3.2 (2026年6月)
- 核心功能：模型训练、推理服务、Agent编排
- 支持模型：GPT-4o, Claude 4, Gemini 2.5, Qwen3
- API限制：10000 req/min, 上下文窗口128K

### 常见问题知识库
1. 速率限制问题 → 建议实现指数退避重试
2. 上下文溢出 → 建议使用RAG或对话摘要
3. 输出格式问题 → 建议使用Structured Output功能
4. 模型选择困惑 → 根据场景推荐（见选型矩阵）

### 内部编码规范
- 函数命名：snake_case
- 类命名：PascalCase
- 常量：UPPER_SNAKE_CASE
- 注释：复杂逻辑必须有注释
- 错误处理：使用自定义异常类

class SystemPromptBuilder:
    """System Prompt 模块化构建器"""
    
    def __init__(self):
        self.identity = ""
        self.constraints = ""
        self.knowledge = ""
        self.examples = ""
        self.output_format = ""
    
    def set_identity(self, role: str, capabilities: list, style: dict):
        self.identity = self._render_identity(role, capabilities, style)
        return self
    
    def set_constraints(self, rules: list, safety: list):
        self.constraints = self._render_constraints(rules, safety)
        return self
    
    def set_knowledge(self, knowledge_manager: KnowledgeManager, query: str = ""):
        self.knowledge = knowledge_manager.assemble(query)
        return self
    
    def set_output_format(self, format_spec: str):
        self.output_format = format_spec
        return self
    
    def build(self) -> str:
        sections = []
        if self.identity:
            sections.append(f"# 角色设定\n{self.identity}")
        if self.constraints:
            sections.append(f"# 行为规范\n{self.constraints}")
        if self.knowledge:
            sections.append(f"# 知识背景\n{self.knowledge}")
        if self.output_format:
            sections.append(f"# 输出格式\n{self.output_format}")
        return "\n\n---\n\n".join(sections)
    
    def _render_identity(self, role, capabilities, style):
        caps = "\n".join(f"- {c}" for c in capabilities)
        return f"你是{role}。\n\n核心能力：\n{caps}\n\n语言风格：{style}"
    
    def _render_constraints(self, rules, safety):
        rules_str = "\n".join(f"{i+1}. {r}" for i, r in enumerate(rules))
        safety_str = "\n".join(f"- {s}" for s in safety)
        return f"行为规则：\n{rules_str}\n\n安全约束：\n{safety_str}"

class SystemPromptABTest:
    """System Prompt A/B 测试"""
    
    def __init__(self, variant_a: str, variant_b: str):
        self.variant_a = variant_a
        self.variant_b = variant_b
        self.results = {'a': [], 'b': []}
    
    def evaluate(self, test_cases: list) -> dict:
        for case in test_cases:
            # 两个变体分别处理
            result_a = self._run(self.variant_a, case)
            result_b = self._run(self.variant_b, case)
            
            # 多维度评分
            self.results['a'].append(self._score(result_a, case))
            self.results['b'].append(self._score(result_b, case))
        
        return self._compare()
    
    def _score(self, response: str, case: dict) -> dict:
        return {
            'accuracy': self._score_accuracy(response, case),
            'safety': self._score_safety(response),
            'format': self._score_format(response, case),
            'helpfulness': self._score_helpfulness(response, case),
            'conciseness': self._score_conciseness(response),
        }

def optimize_system_prompt(prompt: str, target_tokens: int = 4000) -> str:
    """压缩 System Prompt 到目标 Token 数"""
    current_tokens = estimate_tokens(prompt)
    if current_tokens <= target_tokens:
        return prompt
    
    # 策略1：合并重复规则
    prompt = merge_duplicate_rules(prompt)
    
    # 策略2：知识块压缩（保留关键信息）
    prompt = compress_knowledge_blocks(prompt)
    
    # 策略3：示例精简（保留最有代表性的）
    prompt = reduce_examples(prompt, keep=2)
    
    # 策略4：约束合并（相似规则合并）
    prompt = merge_similar_constraints(prompt)
    
    return prompt