高级Prompt技巧与策略

📖 概述

在掌握基础Prompt编写技巧后，进阶的Prompt工程需要运用更复杂的策略和技巧。本文将深入探讨Chain-of-Thought、Few-shot Learning、Role Playing等高级技术，帮助你构建更强大、更精准的AI交互体验。

🧠 Chain-of-Thought (思维链) 提示

核心原理与机制

维度	说明	技术细节	应用效果
基本概念	引导AI展示推理过程的提示技术	通过"让我们一步步思考"激活推理模式	提高复杂问题的解决准确率
工作机制	模拟人类逐步推理的思维过程	将复杂问题分解为多个推理步骤	增强逻辑性和可解释性
神经基础	激活模型中的序列推理能力	利用Transformer的序列建模优势	改善数学、逻辑推理表现
适用场景	数学计算、逻辑推理、复杂分析	多步骤问题、需要解释的任务	显著提升推理任务准确率

CoT提示模式对比

提示类型	结构特点	示例	适用场景	效果评估
Zero-shot CoT	简单添加推理引导词	"让我们一步步思考这个问题"	通用推理任务	中等提升效果
Few-shot CoT	提供推理示例	给出2-3个完整推理过程示例	复杂推理任务	显著提升效果
Self-Consistency	多次推理取一致结果	生成多个推理路径，选择最一致答案	高准确率要求任务	最高准确率
Tree of Thoughts	树状推理结构	探索多个推理分支	创造性问题解决	最强创造性

实际应用示例

# 基础CoT示例
问题：一家商店原价100元的商品，先打8折，再打9折，最终价格是多少？

Prompt: "让我们一步步计算这个折扣问题：
1. 首先分析题目条件
2. 计算第一次打折后的价格
3. 计算第二次打折后的最终价格
4. 验证计算结果"

# 复杂CoT示例
问题：设计一个Node.js微服务架构

Prompt: "让我们系统性地设计这个微服务架构：

第一步：需求分析
- 分析业务需求和技术要求
- 确定服务边界和职责

第二步：架构设计
- 设计服务拆分策略
- 定义服务间通信方式

第三步：技术选型
- 选择合适的技术栈
- 考虑性能和可维护性

第四步：实现细节
- 设计API接口
- 考虑错误处理和监控

请按照这个思路详细展开每个步骤。"

🎯 Few-shot Learning (少样本学习)

核心机制分析

学习类型	样本数量	学习机制	适用场景	性能特点
Zero-shot	0个示例	纯指令理解	通用任务、简单格式	快速但可能不准确
One-shot	1个示例	模式识别	格式化任务、简单模式	基本模式学习
Few-shot	2-5个示例	模式泛化	复杂格式、特定风格	最佳平衡点
Many-shot	5+个示例	深度模式学习	复杂任务、高精度要求	高精度但成本高

Few-shot设计策略

策略维度	设计原则	具体方法	注意事项
示例选择	代表性和多样性	覆盖不同情况和边界案例	避免偏向性示例
示例质量	高质量标准答案	确保示例准确无误	错误示例会误导模型
示例数量	平衡效果和成本	通常2-5个最优	过多示例可能混淆模型
示例顺序	从简单到复杂	渐进式难度安排	最后一个示例影响最大
格式一致性	统一的输入输出格式	保持结构化一致性	格式不一致会降低效果

实际应用案例

# 代码生成Few-shot示例
Prompt: "请根据以下示例，为新的功能生成相应的Node.js代码：

示例1：
功能：用户注册
输入：用户名、邮箱、密码
输出：
```javascript
app.post('/register', async (req, res) => {
  const { username, email, password } = req.body;
  const hashedPassword = await bcrypt.hash(password, 10);
  const user = await User.create({ username, email, password: hashedPassword });
  res.json({ success: true, userId: user.id });
});

示例2： 功能：用户登录 输入：邮箱、密码 输出：

app.post('/login', async (req, res) => {
  const { email, password } = req.body;
  const user = await User.findOne({ email });
  const isValid = await bcrypt.compare(password, user.password);
  if (isValid) {
    const token = jwt.sign({ userId: user.id }, process.env.JWT_SECRET);
    res.json({ success: true, token });
  } else {
    res.status(401).json({ success: false, message: 'Invalid credentials' });
  }
});

现在请为以下功能生成代码： 功能：获取用户信息 输入：用户ID 输出：[请生成相应代码]"

## 🎭 Role Playing (角色扮演) 技术

### 角色设定的心理学基础

| 心理机制 | 作用原理 | 技术实现 | 效果表现 |
|----------|----------|----------|----------|
| **认知框架激活** | 激活特定领域的知识结构 | 明确的专业角色定义 | 专业性回答质量提升 |
| **行为模式引导** | 引导特定的思维和表达方式 | 详细的角色特征描述 | 回答风格更加一致 |
| **上下文约束** | 限制回答范围和方式 | 角色相关的约束条件 | 减少无关信息干扰 |
| **情感色彩塑造** | 影响回答的情感倾向 | 角色性格和态度设定 | 更符合预期的交互体验 |

### 高效角色设定框架

| 设定维度 | 核心要素 | 设定方法 | 示例 |
|----------|----------|----------|------|
| **专业背景** | 领域专长、经验水平 | "你是一名有10年经验的..." | "资深Node.js架构师" |
| **知识结构** | 掌握的技能和知识范围 | "精通...，熟悉..." | "精通微服务架构，熟悉云原生技术" |
| **思维特点** | 分析问题的方式和角度 | "善于...，注重..." | "善于系统性思考，注重实用性" |
| **表达风格** | 语言风格和沟通方式 | "以...方式回答" | "以简洁专业的方式解释复杂概念" |
| **价值观念** | 工作原则和价值取向 | "坚持...，重视..." | "坚持最佳实践，重视代码质量" |
| **行为约束** | 回答的边界和限制 | "不会...，避免..." | "不提供未经验证的方案" |

### 多角色协作策略

多角色协作Prompt示例

Prompt: "现在我们要设计一个电商系统，请分别从以下角色的角度提供建议：

【产品经理角色】 你是一名资深产品经理，有5年电商产品经验。请从用户需求和商业价值角度分析：

1. 核心功能优先级
2. 用户体验设计要点
3. 商业模式考虑

【技术架构师角色】 你是一名资深技术架构师，精通大规模系统设计。请从技术实现角度分析：

1. 系统架构设计
2. 技术栈选择
3. 性能和扩展性考虑

【UI/UX设计师角色】 你是一名经验丰富的UI/UX设计师，专注于电商用户体验。请从设计角度分析：

1. 界面设计原则
2. 用户交互流程
3. 移动端适配考虑

请按照角色顺序，分别提供专业建议，每个角色的建议要体现其专业特点。"

## 🔄 Self-Consistency (自一致性) 方法

### 技术原理与实现

| 实现步骤 | 技术细节 | 参数设置 | 效果评估 |
|----------|----------|----------|----------|
| **多路径生成** | 使用不同的随机种子生成多个回答 | temperature=0.7-1.0 | 增加答案多样性 |
| **一致性检查** | 比较多个回答的核心结论 | 生成3-5个候选答案 | 识别最可靠答案 |
| **投票机制** | 统计最频繁出现的答案 | 简单多数投票或加权投票 | 提高准确率 |
| **置信度评估** | 评估答案的一致性程度 | 计算答案间的相似度 | 量化答案可靠性 |

### 应用场景与效果

| 应用场景 | 适用原因 | 实施方法 | 预期效果 |
|----------|----------|----------|----------|
| **数学计算** | 计算过程可能有多种路径 | 多次计算取一致结果 | 准确率提升20-30% |
| **逻辑推理** | 推理链条可能有分歧 | 多路径推理验证 | 逻辑错误率降低 |
| **代码生成** | 实现方案可能多样 | 生成多个方案比较 | 代码质量更稳定 |
| **创意任务** | 需要平衡创新和合理性 | 多个创意方案筛选 | 创意质量更高 |

## 💡 Node.js实现：高级Prompt技术工具

### Chain-of-Thought实现工具

```javascript
const fs = require('fs');
const path = require('path');

class ChainOfThoughtProcessor {
  constructor(config = {}) {
    this.config = {
      maxSteps: config.maxSteps || 10,
      stepDelimiter: config.stepDelimiter || '\n\n',
      thinkingTriggers: config.thinkingTriggers || [
        '让我们一步步思考',
        '让我逐步分析',
        '我需要仔细考虑',
        '让我们系统性地解决这个问题'
      ],
      ...config
    };
    
    this.reasoningPatterns = {
      mathematical: {
        name: '数学推理模式',
        structure: [
          '理解问题：分析题目给出的条件和要求',
          '制定策略：选择合适的解题方法',
          '执行计算：按步骤进行计算',
          '验证结果：检查答案的合理性'
        ]
      },
      analytical: {
        name: '分析推理模式',
        structure: [
          '问题定义：明确需要分析的核心问题',
          '信息收集：整理相关的事实和数据',
          '多角度分析：从不同维度进行分析',
          '综合结论：基于分析得出结论'
        ]
      },
      creative: {
        name: '创造性推理模式',
        structure: [
          '需求理解：深入理解创作要求',
          '灵感发散：产生多个创意方向',
          '方案筛选：评估和选择最佳方案',
          '细化完善：完善创意的具体实现'
        ]
      },
      technical: {
        name: '技术推理模式',
        structure: [
          '需求分析：分析技术需求和约束',
          '方案设计：设计技术实现方案',
          '实现规划：规划具体实现步骤',
          '风险评估：评估潜在风险和解决方案'
        ]
      }
    };
  }

  generateCoTPrompt(originalPrompt, reasoningType = 'analytical') {
    const pattern = this.reasoningPatterns[reasoningType];
    if (!pattern) {
      throw new Error(`推理模式 "${reasoningType}" 不存在`);
    }

    console.log(`\n🧠 生成${pattern.name}的CoT提示`);
    console.log('=' .repeat(50));

    const cotPrompt = `${originalPrompt}

请按照以下思维链条逐步分析：

${pattern.structure.map((step, index) => `${index + 1}. ${step}`).join('\n')}

在每个步骤中，请详细说明你的思考过程和推理依据。最后提供完整的结论。`;

    console.log('📝 生成的CoT Prompt:');
    console.log(cotPrompt);

    return cotPrompt;
  }

  analyzeReasoningQuality(response) {
    console.log('\n🔍 推理质量分析');
    console.log('=' .repeat(30));

    const analysis = {
      stepCount: 0,
      logicalFlow: 0,
      evidenceSupport: 0,
      conclusionClarity: 0,
      overallScore: 0
    };

    // 分析推理步骤数量
    const steps = response.split(/\d+\.|第[一二三四五六七八九十]+步|首先|其次|然后|最后|因此/);
    analysis.stepCount = Math.max(0, steps.length - 1);

    // 分析逻辑流畅性（简化实现）
    const logicalConnectors = ['因为', '所以', '因此', '由于', '基于', '根据', '综上'];
    const connectorCount = logicalConnectors.reduce((count, connector) => {
      return count + (response.match(new RegExp(connector, 'g')) || []).length;
    }, 0);
    analysis.logicalFlow = Math.min(100, connectorCount * 20);

    // 分析证据支持度
    const evidenceKeywords = ['数据显示', '研究表明', '例如', '具体来说', '实际上'];
    const evidenceCount = evidenceKeywords.reduce((count, keyword) => {
      return count + (response.match(new RegExp(keyword, 'g')) || []).length;
    }, 0);
    analysis.evidenceSupport = Math.min(100, evidenceCount * 25);

    // 分析结论清晰度
    const conclusionKeywords = ['总结', '结论', '综上所述', '最终', '答案是'];
    const hasConclusion = conclusionKeywords.some(keyword => response.includes(keyword));
    analysis.conclusionClarity = hasConclusion ? 80 : 40;

    // 计算总分
    analysis.overallScore = Math.round(
      (analysis.logicalFlow * 0.3 + 
       analysis.evidenceSupport * 0.3 + 
       analysis.conclusionClarity * 0.4)
    );

    // 显示分析结果
    console.log(`推理步骤数量: ${analysis.stepCount}`);
    console.log(`逻辑流畅性: ${analysis.logicalFlow}/100`);
    console.log(`证据支持度: ${analysis.evidenceSupport}/100`);
    console.log(`结论清晰度: ${analysis.conclusionClarity}/100`);
    console.log(`综合评分: ${analysis.overallScore}/100`);

    // 提供改进建议
    const suggestions = this.generateImprovementSuggestions(analysis);
    if (suggestions.length > 0) {
      console.log('\n💡 改进建议:');
      suggestions.forEach((suggestion, index) => {
        console.log(`${index + 1}. ${suggestion}`);
      });
    }

    return analysis;
  }

  generateImprovementSuggestions(analysis) {
    const suggestions = [];

    if (analysis.stepCount < 3) {
      suggestions.push('增加推理步骤，将复杂问题分解为更多子步骤');
    }

    if (analysis.logicalFlow < 60) {
      suggestions.push('使用更多逻辑连接词，如"因为"、"所以"、"因此"等');
    }

    if (analysis.evidenceSupport < 50) {
      suggestions.push('添加更多具体的证据和例子来支持推理');
    }

    if (analysis.conclusionClarity < 70) {
      suggestions.push('在结尾明确总结结论，使用"总结"、"结论"等关键词');
    }

    return suggestions;
  }

  createReasoningTemplate(problemType, customSteps = []) {
    console.log(`\n📋 创建${problemType}推理模板`);
    
    const baseTemplate = {
      introduction: `让我们系统性地分析这个${problemType}问题：`,
      steps: customSteps.length > 0 ? customSteps : [
        '问题理解：仔细分析问题的核心要求',
        '信息整理：整理已知条件和相关信息',
        '方法选择：选择合适的分析或解决方法',
        '逐步执行：按照选定方法逐步执行',
        '结果验证：检查结果的合理性和准确性',
        '总结归纳：总结解决过程和关键要点'
      ],
      conclusion: '基于以上分析，我的结论是：'
    };

    const template = `${baseTemplate.introduction}

${baseTemplate.steps.map((step, index) => `**第${index + 1}步：${step}**\n[在此详细展开分析]`).join('\n\n')}

**${baseTemplate.conclusion}**\n[在此给出明确结论]`;

    console.log('📄 生成的推理模板:');
    console.log(template);

    return template;
  }

  batchProcessCoT(prompts, reasoningType = 'analytical') {
    console.log(`\n🔄 批量处理${prompts.length}个CoT提示`);
    
    const results = prompts.map((prompt, index) => {
      console.log(`\n处理第${index + 1}个提示...`);
      const cotPrompt = this.generateCoTPrompt(prompt, reasoningType);
      
      return {
        originalPrompt: prompt,
        cotPrompt: cotPrompt,
        reasoningType: reasoningType,
        timestamp: new Date().toISOString()
      };
    });

    // 保存批处理结果
    const outputPath = './cot_batch_results.json';
    fs.writeFileSync(outputPath, JSON.stringify(results, null, 2));
    console.log(`\n💾 批处理结果已保存到: ${outputPath}`);

    return results;
  }
}

// Few-shot学习工具
class FewShotLearningGenerator {
  constructor() {
    this.exampleTemplates = {
      classification: {
        name: '分类任务模板',
        structure: '输入: {input}\n输出: {output}\n解释: {explanation}'
      },
      generation: {
        name: '生成任务模板', 
        structure: '需求: {requirement}\n生成结果:\n{result}'
      },
      transformation: {
        name: '转换任务模板',
        structure: '原始: {original}\n转换为: {transformed}\n转换规则: {rule}'
      },
      qa: {
        name: '问答任务模板',
        structure: 'Q: {question}\nA: {answer}'
      }
    };
  }

  generateFewShotPrompt(taskDescription, examples, newInput, templateType = 'qa') {
    console.log(`\n🎯 生成Few-shot学习提示`);
    console.log(`任务类型: ${this.exampleTemplates[templateType].name}`);
    console.log(`示例数量: ${examples.length}`);
    console.log('=' .repeat(40));

    const template = this.exampleTemplates[templateType];
    
    // 构建示例部分
    const exampleSection = examples.map((example, index) => {
      let formattedExample = template.structure;
      
      // 替换模板变量
      Object.keys(example).forEach(key => {
        formattedExample = formattedExample.replace(`{${key}}`, example[key]);
      });
      
      return `示例${index + 1}:\n${formattedExample}`;
    }).join('\n\n');

    // 构建完整提示
    const fewShotPrompt = `${taskDescription}

${exampleSection}

现在请处理新的输入：
${this.formatNewInput(newInput, templateType)}`;

    console.log('📝 生成的Few-shot Prompt:');
    console.log(fewShotPrompt);

    return fewShotPrompt;
  }

  formatNewInput(input, templateType) {
    const formatMap = {
      classification: `输入: ${input}\n输出: [请分类]`,
      generation: `需求: ${input}\n生成结果: [请生成]`,
      transformation: `原始: ${input}\n转换为: [请转换]`,
      qa: `Q: ${input}\nA: [请回答]`
    };
    
    return formatMap[templateType] || input;
  }

  optimizeExampleSelection(allExamples, targetInput, maxExamples = 3) {
    console.log('\n🔍 优化示例选择');
    console.log(`从${allExamples.length}个候选示例中选择${maxExamples}个最佳示例`);

    // 简化的相似度计算（实际应用中可以使用更复杂的算法）
    const scoredExamples = allExamples.map(example => {
      const similarity = this.calculateSimilarity(example.input || example.question, targetInput);
      const diversity = this.calculateDiversity(example, allExamples);
      const quality = this.assessExampleQuality(example);
      
      const totalScore = similarity * 0.4 + diversity * 0.3 + quality * 0.3;
      
      return {
        ...example,
        similarity,
        diversity,
        quality,
        totalScore
      };
    });

    // 选择得分最高的示例
    const selectedExamples = scoredExamples
      .sort((a, b) => b.totalScore - a.totalScore)
      .slice(0, maxExamples);

    console.log('✅ 选择的示例:');
    selectedExamples.forEach((example, index) => {
      console.log(`${index + 1}. 相似度: ${example.similarity.toFixed(2)}, 多样性: ${example.diversity.toFixed(2)}, 质量: ${example.quality.toFixed(2)}`);
    });

    return selectedExamples;
  }

  calculateSimilarity(text1, text2) {
    // 简化的文本相似度计算
    const words1 = text1.toLowerCase().split(/\s+/);
    const words2 = text2.toLowerCase().split(/\s+/);
    
    const intersection = words1.filter(word => words2.includes(word));
    const union = [...new Set([...words1, ...words2])];
    
    return intersection.length / union.length;
  }

  calculateDiversity(example, allExamples) {
    // 计算示例的多样性（与其他示例的差异程度）
    const similarities = allExamples
      .filter(other => other !== example)
      .map(other => this.calculateSimilarity(
        example.input || example.question,
        other.input || other.question
      ));
    
    const avgSimilarity = similarities.reduce((sum, sim) => sum + sim, 0) / similarities.length;
    return 1 - avgSimilarity; // 相似度越低，多样性越高
  }

  assessExampleQuality(example) {
    // 评估示例质量
    let score = 0.5; // 基础分
    
    // 检查输出长度（不能太短或太长）
    const output = example.output || example.answer || '';
    if (output.length > 10 && output.length < 500) {
      score += 0.2;
    }
    
    // 检查是否有解释
    if (example.explanation) {
      score += 0.2;
    }
    
    // 检查格式完整性
    const requiredFields = ['input', 'output'].filter(field => example[field]);
    score += (requiredFields.length / 2) * 0.1;
    
    return Math.min(1, score);
  }

  generateExampleVariations(baseExample, variationCount = 3) {
    console.log(`\n🔄 生成${variationCount}个示例变体`);
    
    const variations = [];
    
    for (let i = 0; i < variationCount; i++) {
      const variation = { ...baseExample };
      
      // 简单的变体生成策略
      if (variation.input) {
        variation.input = this.createInputVariation(variation.input, i);
      }
      
      if (variation.question) {
        variation.question = this.createInputVariation(variation.question, i);
      }
      
      variations.push(variation);
    }
    
    console.log('✨ 生成的变体示例:');
    variations.forEach((variation, index) => {
      console.log(`变体${index + 1}: ${JSON.stringify(variation, null, 2)}`);
    });
    
    return variations;
  }

  createInputVariation(originalInput, variationIndex) {
    // 简化的输入变体生成
    const variations = [
      originalInput.replace(/第一/, '第二').replace(/首先/, '其次'),
      originalInput.replace(/简单/, '复杂').replace(/基础/, '高级'),
      originalInput + '（进阶版本）'
    ];
    
    return variations[variationIndex] || originalInput;
  }
}

// 使用示例
const cotProcessor = new ChainOfThoughtProcessor();
const fewShotGenerator = new FewShotLearningGenerator();

console.log('🚀 高级Prompt技术工具演示\n');

// CoT示例
const mathProblem = "一个项目需要3个开发者工作5天完成，如果增加2个开发者，需要多少天完成？";
const cotPrompt = cotProcessor.generateCoTPrompt(mathProblem, 'mathematical');

// Few-shot示例
const codeExamples = [
  {
    requirement: "创建一个Express路由处理用户注册",
    result: "app.post('/register', (req, res) => {\n  // 处理注册逻辑\n});"
  },
  {
    requirement: "创建一个Express路由处理用户登录", 
    result: "app.post('/login', (req, res) => {\n  // 处理登录逻辑\n});"
  }
];

const fewShotPrompt = fewShotGenerator.generateFewShotPrompt(
  "请根据以下示例，生成相应的Express路由代码：",
  codeExamples,
  "创建一个Express路由处理用户信息更新",
  'generation'
);

module.exports = { ChainOfThoughtProcessor, FewShotLearningGenerator };

角色扮演系统

class RolePlayingSystem {
  constructor() {
    this.roleTemplates = {
      technical_expert: {
        name: '技术专家',
        basePrompt: '你是一名资深的{domain}专家，拥有{experience}年的实战经验。',
        characteristics: [
          '深入理解技术原理和最佳实践',
          '能够提供实用的解决方案',
          '注重代码质量和性能优化',
          '善于解释复杂的技术概念'
        ],
        constraints: [
          '只提供经过验证的技术方案',
          '避免推荐过时或不稳定的技术',
          '必须考虑实际项目的可行性'
        ]
      },
      
      product_manager: {
        name: '产品经理',
        basePrompt: '你是一名经验丰富的产品经理，专注于{product_type}产品，有{experience}年的产品管理经验。',
        characteristics: [
          '深刻理解用户需求和市场趋势',
          '善于平衡技术实现和商业价值',
          '具备数据驱动的决策能力',
          '能够协调不同团队的工作'
        ],
        constraints: [
          '决策必须基于用户价值',
          '考虑技术实现的复杂度和成本',
          '关注产品的长期发展规划'
        ]
      },
      
      educator: {
        name: '教育专家',
        basePrompt: '你是一名{subject}领域的资深教育专家，擅长{teaching_style}教学方式。',
        characteristics: [
          '能够将复杂概念简化为易懂的内容',
          '善于设计循序渐进的学习路径',
          '注重实践和理论的结合',
          '能够激发学习者的兴趣和动机'
        ],
        constraints: [
          '内容必须准确无误',
          '适应不同学习者的水平',
          '提供可操作的学习建议'
        ]
      },
      
      consultant: {
        name: '咨询顾问',
        basePrompt: '你是一名{industry}行业的资深咨询顾问，专门帮助企业解决{specialty}相关问题。',
        characteristics: [
          '具备深厚的行业洞察力',
          '能够快速识别问题的核心',
          '提供系统性的解决方案',
          '注重方案的可执行性和ROI'
        ],
        constraints: [
          '建议必须基于实际情况',
          '考虑企业的资源和约束',
          '提供可量化的预期效果'
        ]
      }
    };
    
    this.conversationHistory = [];
  }

  createRole(roleType, customizations = {}) {
    const template = this.roleTemplates[roleType];
    if (!template) {
      throw new Error(`角色类型 "${roleType}" 不存在`);
    }

    console.log(`\n🎭 创建${template.name}角色`);
    console.log('=' .repeat(30));

    // 构建角色提示
    let rolePrompt = template.basePrompt;
    
    // 替换自定义变量
    Object.keys(customizations).forEach(key => {
      rolePrompt = rolePrompt.replace(`{${key}}`, customizations[key]);
    });

    // 添加角色特征
    const characteristicsText = template.characteristics
      .map(char => `- ${char}`)
      .join('\n');
    
    // 添加行为约束
    const constraintsText = template.constraints
      .map(constraint => `- ${constraint}`)
      .join('\n');

    const fullRolePrompt = `${rolePrompt}

你的专业特征：
${characteristicsText}

请遵循以下原则：
${constraintsText}

请始终保持这个角色的专业性和一致性。`;

    console.log('📝 生成的角色提示:');
    console.log(fullRolePrompt);

    return {
      roleType,
      roleName: template.name,
      rolePrompt: fullRolePrompt,
      customizations,
      createdAt: new Date().toISOString()
    };
  }

  createMultiRoleScenario(roles, scenario, collaborationType = 'sequential') {
    console.log(`\n👥 创建多角色协作场景`);
    console.log(`协作类型: ${collaborationType}`);
    console.log(`参与角色: ${roles.map(r => r.roleName).join(', ')}`);
    console.log('=' .repeat(50));

    let scenarioPrompt = '';

    if (collaborationType === 'sequential') {
      // 顺序协作：角色依次发言
      scenarioPrompt = `场景描述：${scenario}

请按照以下顺序，分别从不同角色的专业角度提供建议：

`;
      
      roles.forEach((role, index) => {
        scenarioPrompt += `【${role.roleName}的观点】
${role.rolePrompt}

针对上述场景，请提供你的专业建议：
[请在此提供${role.roleName}的专业观点]

`;
      });
      
    } else if (collaborationType === 'debate') {
      // 辩论模式：角色间进行讨论
      scenarioPrompt = `辩论场景：${scenario}

参与辩论的角色：
`;
      
      roles.forEach((role, index) => {
        scenarioPrompt += `${index + 1}. ${role.roleName}：${role.rolePrompt.split('\n')[0]}\n`;
      });
      
      scenarioPrompt += `
请模拟这些角色之间的专业讨论，每个角色都要：
1. 表达自己的专业观点
2. 回应其他角色的观点
3. 寻求最佳的解决方案

开始讨论：`;
      
    } else if (collaborationType === 'workshop') {
      // 工作坊模式：协作解决问题
      scenarioPrompt = `工作坊场景：${scenario}

工作坊参与者：
`;
      
      roles.forEach((role, index) => {
        scenarioPrompt += `- ${role.roleName}：负责${this.getRoleResponsibility(role.roleType)}\n`;
      });
      
      scenarioPrompt += `
请模拟一个协作工作坊，各角色需要：
1. 分享各自的专业见解
2. 协作制定解决方案
3. 确保方案的可行性和完整性

工作坊开始：`;
    }

    console.log('📋 生成的多角色场景提示:');
    console.log(scenarioPrompt);

    return {
      scenario,
      collaborationType,
      roles,
      scenarioPrompt,
      createdAt: new Date().toISOString()
    };
  }

  getRoleResponsibility(roleType) {
    const responsibilities = {
      technical_expert: '技术方案设计和实现指导',
      product_manager: '需求分析和产品规划',
      educator: '知识传授和学习指导',
      consultant: '战略建议和问题解决'
    };
    
    return responsibilities[roleType] || '专业建议提供';
  }

  analyzeRoleConsistency(response, role) {
    console.log(`\n🔍 分析${role.roleName}角色一致性`);
    
    const analysis = {
      professionalTerms: 0,
      roleCharacteristics: 0,
      constraintCompliance: 0,
      overallConsistency: 0
    };

    // 检查专业术语使用
    const professionalKeywords = this.getProfessionalKeywords(role.roleType);
    const termCount = professionalKeywords.reduce((count, term) => {
      return count + (response.toLowerCase().includes(term.toLowerCase()) ? 1 : 0);
    }, 0);
    analysis.professionalTerms = Math.min(100, (termCount / professionalKeywords.length) * 100);

    // 检查角色特征体现
    const template = this.roleTemplates[role.roleType];
    const characteristicKeywords = this.extractKeywords(template.characteristics);
    const charCount = characteristicKeywords.reduce((count, keyword) => {
      return count + (response.toLowerCase().includes(keyword.toLowerCase()) ? 1 : 0);
    }, 0);
    analysis.roleCharacteristics = Math.min(100, (charCount / characteristicKeywords.length) * 150);

    // 检查约束遵循
    const constraintViolations = this.checkConstraintViolations(response, template.constraints);
    analysis.constraintCompliance = Math.max(0, 100 - (constraintViolations * 25));

    // 计算总体一致性
    analysis.overallConsistency = Math.round(
      (analysis.professionalTerms * 0.3 + 
       analysis.roleCharacteristics * 0.4 + 
       analysis.constraintCompliance * 0.3)
    );

    console.log(`专业术语使用: ${analysis.professionalTerms.toFixed(1)}/100`);
    console.log(`角色特征体现: ${analysis.roleCharacteristics.toFixed(1)}/100`);
    console.log(`约束遵循度: ${analysis.constraintCompliance}/100`);
    console.log(`总体一致性: ${analysis.overallConsistency}/100`);

    return analysis;
  }

  getProfessionalKeywords(roleType) {
    const keywords = {
      technical_expert: ['架构', '性能', '优化', '最佳实践', '技术栈', '框架', '算法', '数据结构'],
      product_manager: ['用户需求', '市场', '功能', '优先级', '路线图', 'KPI', '用户体验', '商业价值'],
      educator: ['学习', '教学', '理解', '掌握', '练习', '实践', '循序渐进', '知识点'],
      consultant: ['分析', '建议', '方案', '策略', '优化', '效率', '成本', 'ROI']
    };
    
    return keywords[roleType] || [];
  }

  extractKeywords(characteristics) {
    return characteristics.join(' ')
      .match(/[\u4e00-\u9fa5a-zA-Z]+/g)
      .filter(word => word.length > 1)
      .slice(0, 10); // 取前10个关键词
  }

  checkConstraintViolations(response, constraints) {
    // 简化的约束检查
    let violations = 0;
    
    constraints.forEach(constraint => {
      if (constraint.includes('不') || constraint.includes('避免')) {
        // 检查是否违反了"不要做"的约束
        const forbiddenActions = constraint.match(/不[要会]?([^，。]+)/g);
        if (forbiddenActions) {
          forbiddenActions.forEach(action => {
            const cleanAction = action.replace(/不[要会]?/, '');
            if (response.includes(cleanAction)) {
              violations++;
            }
          });
        }
      }
    });
    
    return violations;
  }

  saveRoleConfiguration(role, filename) {
    const config = {
      ...role,
      template: this.roleTemplates[role.roleType],
      savedAt: new Date().toISOString()
    };
    
    const filepath = path.join('./role_configs', `${filename}.json`);
    
    // 确保目录存在
    const dir = path.dirname(filepath);
    if (!fs.existsSync(dir)) {
      fs.mkdirSync(dir, { recursive: true });
    }
    
    fs.writeFileSync(filepath, JSON.stringify(config, null, 2));
    console.log(`\n💾 角色配置已保存到: ${filepath}`);
  }
}

// 使用示例
const roleSystem = new RolePlayingSystem();

console.log('\n🎭 角色扮演系统演示');

// 创建技术专家角色
const techExpert = roleSystem.createRole('technical_expert', {
  domain: 'Node.js全栈开发',
  experience: '8'
});

// 创建产品经理角色
const productManager = roleSystem.createRole('product_manager', {
  product_type: '企业级SaaS',
  experience: '6'
});

// 创建多角色协作场景
const scenario = roleSystem.createMultiRoleScenario(
  [techExpert, productManager],
  '设计一个AI驱动的客户服务系统，需要考虑技术实现和产品策略',
  'workshop'
);

module.exports = RolePlayingSystem;

🎯 学习检验

理论理解检验

1. CoT机制：能否解释思维链提示的工作原理和适用场景？
2. Few-shot原理：能否说明少样本学习的机制和示例设计原则？
3. 角色扮演：能否分析角色设定对AI输出的影响机制？
4. 自一致性：能否理解多路径推理和一致性检查的价值？

实践能力检验

1. 技巧应用：能否在实际场景中正确应用各种高级技巧？
2. 组合使用：能否将多种技巧有效组合使用？
3. 效果评估：能否评估和优化高级Prompt的效果？
4. 场景适配：能否根据不同场景选择合适的技巧？

🚀 实践项目建议

基础应用项目

1. CoT推理工具：开发自动生成思维链提示的工具
2. Few-shot模板库：构建不同任务的Few-shot模板集合
3. 角色扮演系统：创建多角色协作的对话系统
4. 技巧效果测试：比较不同技巧在各场景下的效果

高级综合项目

1. 智能Prompt优化器：结合多种技巧的自动优化系统
2. 专业领域助手：针对特定领域的高级Prompt应用
3. 协作决策平台：多角色协作的决策支持系统
4. Prompt效果分析平台：科学评估Prompt技巧效果的平台

📚 延伸阅读

核心论文

1. "Chain-of-Thought Prompting Elicits Reasoning in Large Language Models" - CoT原理论文
2. "Self-Consistency Improves Chain of Thought Reasoning" - 自一致性方法
3. "Tree of Thoughts: Deliberate Problem Solving with Large Language Models" - 思维树方法
4. "Few-Shot Learning with Language Models" - 少样本学习综述

实践指南

1. OpenAI Prompt Engineering Guide - 官方高级技巧指南
2. Anthropic Constitutional AI - 角色约束和安全性
3. Google PaLM Prompting Guide - 大模型提示最佳实践
4. Microsoft Prompt Engineering Patterns - 提示工程模式

---

💡 学习提示：高级Prompt技巧需要大量实践才能熟练掌握。建议从单一技巧开始，逐步尝试组合使用。关注不同技巧的适用场景和局限性，并通过实际项目验证效果。记录成功的模式和失败的教训，建立自己的Prompt技巧库。