摘要
角色扮演是ChatGPT最强大的功能之一，通过精心设计的提示词，我们可以让AI扮演各种专业角色，从Linux终端到心理咨询师，从代码审查员到创意写手。本文将深入分析awesome-chatgpt-prompts项目中的角色扮演技术，揭示其背后的原理和实现方法，帮助开发者掌握这一核心技能。
目录
角色扮演技术概述
什么是AI角色扮演
AI角色扮演是通过特定的提示词设计，让AI模型模拟特定角色的行为、知识和语言风格的技术。这种技术能够让AI在特定领域表现出专业性和一致性。
角色扮演的技术原理
class RolePlayingEngine:
"""角色扮演引擎核心类"""
def __init__(self):
self.role_templates = {}
self.context_memory = []
self.personality_traits = {}
def define_role(self, role_name, attributes):
"""
定义角色属性
Args:
role_name: 角色名称
attributes: 角色属性字典
"""
self.role_templates[role_name] = {
'profession': attributes.get('profession', ''),
'expertise': attributes.get('expertise', []),
'personality': attributes.get('personality', {}),
'communication_style': attributes.get('communication_style', ''),
'knowledge_base': attributes.get('knowledge_base', []),
'constraints': attributes.get('constraints', [])
}
def generate_role_prompt(self, role_name, task_context):
"""
生成角色扮演提示词
Args:
role_name: 角色名称
task_context: 任务上下文
Returns:
完整的角色扮演提示词
"""
if role_name not in self.role_templates:
raise ValueError(f"角色 {role_name} 未定义")
role = self.role_templates[role_name]
prompt = f"""
你现在要扮演一位{role['profession']}。
角色背景：
- 专业领域：{', '.join(role['expertise'])}
- 性格特点：{self._format_personality(role['personality'])}
- 沟通风格：{role['communication_style']}
专业知识：
{self._format_knowledge_base(role['knowledge_base'])}
行为约束：
{self._format_constraints(role['constraints'])}
任务上下文：{task_context}
请始终保持角色一致性，以{role['profession']}的身份回答问题。
"""
return prompt.strip()
def _format_personality(self, personality):
"""格式化性格特点"""
if not personality:
return "专业、友善、乐于助人"
traits = []
for trait, description in personality.items():
traits.append(f"{trait}({description})")
return "、".join(traits)
def _format_knowledge_base(self, knowledge_base):
"""格式化知识库"""
if not knowledge_base:
return "- 具备相关领域的专业知识"
formatted = []
for knowledge in knowledge_base:
formatted.append(f"- {knowledge}")
return "\n".join(formatted)
def _format_constraints(self, constraints):
"""格式化行为约束"""
if not constraints:
return "- 保持专业和准确"
formatted = []
for constraint in constraints:
formatted.append(f"- {constraint}")
return "\n".join(formatted)
# 使用示例
engine = RolePlayingEngine()
# 定义Python专家角色
python_expert = {
'profession': 'Python高级开发工程师',
'expertise': ['Python编程', '代码优化', '架构设计', '最佳实践'],
'personality': {
'严谨': '注重代码质量和规范',
'耐心': '善于解释复杂概念',
'实用': '提供可行的解决方案'
},
'communication_style': '技术准确、逻辑清晰、示例丰富',
'knowledge_base': [
'熟悉Python 3.x所有特性',
'精通常用框架如Django、Flask、FastAPI',
'了解性能优化和调试技巧',
'掌握测试驱动开发'
],
'constraints': [
'只提供Python相关的建议',
'代码示例必须可运行',
'遵循PEP 8编码规范',
'不推荐过时的做法'
]
}
engine.define_role('python_expert', python_expert)
# 生成提示词
prompt = engine.generate_role_prompt(
'python_expert',
'用户想要优化一个处理大量数据的Python脚本'
)
print(prompt)
角色设计的核心要素
1. 专业身份定义
专业身份是角色扮演的基础，需要明确角色的职业、经验水平和专业领域。
class ProfessionalIdentity:
"""专业身份定义类"""
def __init__(self, title, experience_level, domain):
self.title = title # 职业头衔
self.experience_level = experience_level # 经验水平
self.domain = domain # 专业领域
self.certifications = [] # 认证资质
self.achievements = [] # 主要成就
def add_certification(self, cert_name, issuer, year):
"""添加专业认证"""
self.certifications.append({
'name': cert_name,
'issuer': issuer,
'year': year
})
def add_achievement(self, achievement):
"""添加专业成就"""
self.achievements.append(achievement)
def generate_identity_description(self):
"""生成身份描述"""
description = f"我是一位{self.experience_level}的{self.title}，专注于{self.domain}领域。"
if self.certifications:
cert_list = [cert['name'] for cert in self.certifications]
description += f"\n\n我拥有以下专业认证：{', '.join(cert_list)}。"
if self.achievements:
description += f"\n\n主要成就包括：\n"
for achievement in self.achievements:
description += f"- {achievement}\n"
return description
# 示例：创建数据科学家身份
data_scientist = ProfessionalIdentity(
title="数据科学家",
experience_level="资深",
domain="机器学习和数据分析"
)
data_scientist.add_certification("AWS Certified Machine Learning", "Amazon", 2023)
data_scientist.add_certification("Google Cloud Professional Data Engineer", "Google", 2022)
data_scientist.add_achievement("领导开发了公司核心推荐系统，提升用户转化率30%")
data_scientist.add_achievement("发表了5篇机器学习领域的学术论文")
data_scientist.add_achievement("指导团队完成了10+个数据科学项目")
print(data_scientist.generate_identity_description())
2. 知识体系构建
mindmap
root((知识体系))
理论基础
核心概念
基本原理
发展历史
实践技能
工具使用
方法论
最佳实践
经验积累
案例分析
问题解决
教训总结
前沿动态
新技术
趋势分析
未来展望
3. 性格特征塑造
class PersonalityTraits:
"""性格特征类"""
def __init__(self):
self.traits = {
'communication_style': '', # 沟通风格
'problem_solving_approach': '', # 问题解决方式
'teaching_style': '', # 教学风格
'emotional_tone': '', # 情感基调
'humor_level': '', # 幽默程度
'formality_level': '' # 正式程度
}
def set_trait(self, trait_name, value):
"""设置性格特征"""
if trait_name in self.traits:
self.traits[trait_name] = value
def generate_personality_prompt(self):
"""生成性格特征提示词"""
prompt_parts = []
if self.traits['communication_style']:
prompt_parts.append(f"沟通风格：{self.traits['communication_style']}")
if self.traits['problem_solving_approach']:
prompt_parts.append(f"解决问题时：{self.traits['problem_solving_approach']}")
if self.traits['teaching_style']:
prompt_parts.append(f"教学方式：{self.traits['teaching_style']}")
if self.traits['emotional_tone']:
prompt_parts.append(f"情感表达：{self.traits['emotional_tone']}")
return "\n".join(prompt_parts)
# 示例：创建友善导师型性格
mentor_personality = PersonalityTraits()
mentor_personality.set_trait('communication_style', '耐心细致，善于倾听')
mentor_personality.set_trait('problem_solving_approach', '循序渐进，注重理解过程')
mentor_personality.set_trait('teaching_style', '启发式教学，鼓励思考')
mentor_personality.set_trait('emotional_tone', '温和友善，积极正面')
print(mentor_personality.generate_personality_prompt())
经典角色案例分析
案例1：Linux终端模拟器
这是awesome-chatgpt-prompts中最受欢迎的角色之一，让我们深入分析其设计精髓。
class LinuxTerminalRole:
"""Linux终端角色实现"""
def __init__(self):
self.current_directory = "/home/user"
self.file_system = self._initialize_filesystem()
self.command_history = []
self.environment_vars = {
'HOME': '/home/user',
'PATH': '/usr/local/bin:/usr/bin:/bin',
'USER': 'user',
'SHELL': '/bin/bash'
}
def _initialize_filesystem(self):
"""初始化虚拟文件系统"""
return {
'/': ['home', 'usr', 'var', 'etc', 'tmp'],
'/home': ['user'],
'/home/user': ['Documents', 'Downloads', 'Desktop', '.bashrc'],
'/home/user/Documents': ['project1', 'notes.txt'],
'/home/user/Downloads': ['file.zip'],
'/usr': ['bin', 'local'],
'/usr/bin': ['python3', 'git', 'vim'],
'/var': ['log'],
'/etc': ['passwd', 'hosts']
}
def execute_command(self, command):
"""
执行Linux命令并返回输出
Args:
command: 用户输入的命令
Returns:
命令执行结果
"""
self.command_history.append(command)
# 解析命令
parts = command.strip().split()
if not parts:
return ""
cmd = parts[0]
args = parts[1:] if len(parts) > 1 else []
# 命令处理
if cmd == 'pwd':
return self.current_directory
elif cmd == 'ls':
return self._handle_ls(args)
elif cmd == 'cd':
return self._handle_cd(args)
elif cmd == 'echo':
return ' '.join(args)
elif cmd == 'whoami':
return self.environment_vars.get('USER', 'user')
elif cmd == 'date':
from datetime import datetime
return datetime.now().strftime("%a %b %d %H:%M:%S %Z %Y")
elif cmd == 'history':
return self._handle_history()
else:
return f"bash: {cmd}: command not found"
def _handle_ls(self, args):
"""处理ls命令"""
target_dir = self.current_directory
show_hidden = False
long_format = False
# 解析参数
for arg in args:
if arg.startswith('-'):
if 'a' in arg:
show_hidden = True
if 'l' in arg:
long_format = True
else:
# 处理目录参数
if arg.startswith('/'):
target_dir = arg
else:
target_dir = f"{self.current_directory}/{arg}".replace('//', '/')
# 获取目录内容
contents = self.file_system.get(target_dir, [])
if not contents:
return f"ls: cannot access '{target_dir}': No such file or directory"
# 过滤隐藏文件
if not show_hidden:
contents = [item for item in contents if not item.startswith('.')]
if long_format:
# 长格式输出
result = []
for item in contents:
if item.startswith('.'):
result.append(f"-rw-r--r-- 1 user user 1024 Jul 14 22:30 {item}")
else:
result.append(f"drwxr-xr-x 2 user user 4096 Jul 14 22:30 {item}")
return '\n'.join(result)
else:
return ' '.join(contents)
def _handle_cd(self, args):
"""处理cd命令"""
if not args:
self.current_directory = self.environment_vars['HOME']
return ""
target = args[0]
if target == '..':
# 返回上级目录
if self.current_directory != '/':
self.current_directory = '/'.join(self.current_directory.split('/')[:-1]) or '/'
elif target.startswith('/'):
# 绝对路径
if target in self.file_system:
self.current_directory = target
else:
return f"bash: cd: {target}: No such file or directory"
else:
# 相对路径
new_path = f"{self.current_directory}/{target}".replace('//', '/')
if new_path in self.file_system:
self.current_directory = new_path
else:
return f"bash: cd: {target}: No such file or directory"
return ""
def _handle_history(self):
"""处理history命令"""
result = []
for i, cmd in enumerate(self.command_history, 1):
result.append(f" {i} {cmd}")
return '\n'.join(result)
def generate_terminal_prompt(self):
"""生成终端提示词"""
return f"""
我要你扮演一个Linux终端。我会输入命令，你需要回复终端应该显示的内容。
规则：
1. 只回复终端输出，不要添加解释
2. 将输出放在代码块中
3. 保持Linux终端的真实行为
4. 支持基本的文件系统操作
当前状态：
- 用户：{self.environment_vars['USER']}
- 当前目录：{self.current_directory}
- Shell：{self.environment_vars['SHELL']}
请等待命令输入。
"""
# 使用示例
terminal = LinuxTerminalRole()
print(terminal.generate_terminal_prompt())
# 模拟命令执行
commands = ['pwd', 'ls', 'cd Documents', 'pwd', 'ls -la']
for cmd in commands:
print(f"$ {cmd}")
output = terminal.execute_command(cmd)
if output:
print(output)
print()
案例2：代码审查专家
class CodeReviewExpert:
"""代码审查专家角色"""
def __init__(self):
self.review_criteria = {
'code_quality': {
'readability': '代码可读性',
'maintainability': '可维护性',
'complexity': '复杂度控制',
'naming': '命名规范'
},
'performance': {
'efficiency': '执行效率',
'memory_usage': '内存使用',
'scalability': '可扩展性'
},
'security': {
'vulnerabilities': '安全漏洞',
'input_validation': '输入验证',
'data_protection': '数据保护'
},
'best_practices': {
'design_patterns': '设计模式',
'error_handling': '错误处理',
'testing': '测试覆盖'
}
}
def analyze_code(self, code, language):
"""
分析代码并生成审查报告
Args:
code: 待审查的代码
language: 编程语言
Returns:
审查报告
"""
analysis = {
'language': language,
'code_length': len(code.split('\n')),
'issues': [],
'suggestions': [],
'score': 0
}
# 基础分析
if language.lower() == 'python':
analysis.update(self._analyze_python_code(code))
elif language.lower() == 'javascript':
analysis.update(self._analyze_javascript_code(code))
return analysis
def _analyze_python_code(self, code):
"""分析Python代码"""
issues = []
suggestions = []
score = 100
lines = code.split('\n')
# 检查代码风格
for i, line in enumerate(lines, 1):
# 检查行长度
if len(line) > 79:
issues.append(f"第{i}行：超过79字符限制 (PEP 8)")
score -= 2
# 检查缩进
if line.strip() and not line.startswith(' ' * 4) and not line.startswith('\t'):
if line.startswith(' '):
issues.append(f"第{i}行：缩进不规范，建议使用4个空格")
score -= 1
# 检查函数定义
if 'def ' in code:
if '"""' not in code and "'''" not in code:
suggestions.append("建议为函数添加文档字符串")
score -= 5
# 检查异常处理
if 'try:' in code and 'except:' in code:
suggestions.append("避免使用裸露的except，应指定具体异常类型")
score -= 3
return {
'issues': issues,
'suggestions': suggestions,
'score': max(0, score)
}
def _analyze_javascript_code(self, code):
"""分析JavaScript代码"""
issues = []
suggestions = []
score = 100
# 检查var使用
if 'var ' in code:
suggestions.append("建议使用let或const替代var")
score -= 5
# 检查分号
lines = [line.strip() for line in code.split('\n') if line.strip()]
for i, line in enumerate(lines, 1):
if line and not line.endswith((';', '{', '}', ')', ']')) and not line.startswith('//'):
issues.append(f"第{i}行：缺少分号")
score -= 1
return {
'issues': issues,
'suggestions': suggestions,
'score': max(0, score)
}
def generate_review_report(self, analysis):
"""生成审查报告"""
report = f"""
代码审查报告
============
语言：{analysis['language']}
代码行数：{analysis['code_length']}
质量评分：{analysis['score']}/100
"""
if analysis['issues']:
report += "发现的问题：\n"
for issue in analysis['issues']:
report += f"❌ {issue}\n"
report += "\n"
if analysis['suggestions']:
report += "改进建议：\n"
for suggestion in analysis['suggestions']:
report += f"💡 {suggestion}\n"
report += "\n"
# 总体评价
if analysis['score'] >= 90:
report += "总体评价：代码质量优秀 ✅"
elif analysis['score'] >= 70:
report += "总体评价：代码质量良好，有改进空间 ⚠️"
else:
report += "总体评价：代码需要重大改进 ❌"
return report
def create_review_prompt(self):
"""创建代码审查提示词"""
return """
我是一位资深的代码审查专家，拥有15年的软件开发经验。
专业领域：
- 多种编程语言的代码审查
- 软件架构设计
- 性能优化
- 安全代码实践
审查标准：
1. 代码质量（可读性、可维护性、复杂度）
2. 性能考虑（效率、内存使用、可扩展性）
3. 安全性（漏洞检测、输入验证）
4. 最佳实践（设计模式、错误处理、测试）
我会提供详细的分析报告，包括：
- 发现的问题和严重程度
- 具体的改进建议
- 重构后的示例代码
- 质量评分和总体评价
请提供需要审查的代码，我将给出专业的反馈。
"""
# 使用示例
reviewer = CodeReviewExpert()
# 示例代码
sample_code = """
def calculate_average(numbers):
total = 0
for num in numbers:
total += num
return total / len(numbers)
def process_data(data):
try:
result = []
for item in data:
if item > 0:
result.append(calculate_average([item, item*2, item*3]))
return result
except:
return None
"""
# 执行代码审查
analysis = reviewer.analyze_code(sample_code, 'Python')
report = reviewer.generate_review_report(analysis)
print(report)
角色一致性维护机制
1. 上下文记忆系统
class ContextMemorySystem:
"""上下文记忆系统"""
def __init__(self, max_memory_size=100):
self.memory = []
self.max_size = max_memory_size
self.role_context = {}
self.conversation_state = {}
def add_interaction(self, user_input, ai_response, role_name):
"""添加交互记录"""
interaction = {
'timestamp': time.time(),
'user_input': user_input,
'ai_response': ai_response,
'role': role_name,
'context_keywords': self._extract_keywords(user_input)
}
self.memory.append(interaction)
# 维护内存大小
if len(self.memory) > self.max_size:
self.memory.pop(0)
# 更新角色上下文
self._update_role_context(role_name, interaction)
def _extract_keywords(self, text):
"""提取关键词"""
# 简化的关键词提取
import re
words = re.findall(r'\b\w+\b', text.lower())
# 过滤常见词汇
stop_words = {'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by'}
keywords = [word for word in words if word not in stop_words and len(word) > 2]
return keywords[:5] # 返回前5个关键词
def _update_role_context(self, role_name, interaction):
"""更新角色上下文"""
if role_name not in self.role_context:
self.role_context[role_name] = {
'interaction_count': 0,
'common_topics': {},
'user_preferences': {},
'conversation_style': {}
}
context = self.role_context[role_name]
context['interaction_count'] += 1
# 统计常见话题
for keyword in interaction['context_keywords']:
context['common_topics'][keyword] = context['common_topics'].get(keyword, 0) + 1
def get_role_context(self, role_name):
"""获取角色上下文"""
return self.role_context.get(role_name, {})
def generate_context_prompt(self, role_name):
"""生成包含上下文的提示词"""
context = self.get_role_context(role_name)
if not context:
return ""
prompt_parts = []
# 添加交互历史信息
if context['interaction_count'] > 0:
prompt_parts.append(f"我们已经进行了{context['interaction_count']}次对话。")
# 添加常见话题
if context['common_topics']:
top_topics = sorted(context['common_topics'].items(), key=lambda x: x[1], reverse=True)[:3]
topics = [topic[0] for topic in top_topics]
prompt_parts.append(f"我们经常讨论的话题包括：{', '.join(topics)}。")
return " ".join(prompt_parts)
# 使用示例
memory_system = ContextMemorySystem()
# 模拟对话记录
memory_system.add_interaction(
"如何优化Python代码性能？",
"可以从算法复杂度、数据结构选择、内存管理等方面优化...",
"python_expert"
)
memory_system.add_interaction(
"什么是装饰器？",
"装饰器是Python中的一种设计模式，用于修改或扩展函数的功能...",
"python_expert"
)
# 获取上下文提示词
context_prompt = memory_system.generate_context_prompt("python_expert")
print("上下文提示词：", context_prompt)
2. 角色一致性检查器
class RoleConsistencyChecker:
"""角色一致性检查器"""
def __init__(self):
self.role_profiles = {}
self.consistency_rules = {
'vocabulary': self._check_vocabulary_consistency,
'tone': self._check_tone_consistency,
'expertise': self._check_expertise_consistency,
'behavior': self._check_behavior_consistency
}
def register_role_profile(self, role_name, profile):
"""注册角色档案"""
self.role_profiles[role_name] = {
'vocabulary': profile.get('vocabulary', []),
'tone_indicators': profile.get('tone_indicators', []),
'expertise_keywords': profile.get('expertise_keywords', []),
'behavior_patterns': profile.get('behavior_patterns', []),
'forbidden_responses': profile.get('forbidden_responses', [])
}
def check_response_consistency(self, role_name, response):
"""检查回复的角色一致性"""
if role_name not in self.role_profiles:
return {'consistent': True, 'warnings': ['角色档案未注册']}
profile = self.role_profiles[role_name]
results = {
'consistent': True,
'warnings': [],
'suggestions': []
}
# 执行各项一致性检查
for check_name, check_func in self.consistency_rules.items():
check_result = check_func(response, profile)
if not check_result['passed']:
results['consistent'] = False
results['warnings'].extend(check_result['warnings'])
results['suggestions'].extend(check_result['suggestions'])
return results
def _check_vocabulary_consistency(self, response, profile):
"""检查词汇一致性"""
expected_vocab = profile.get('vocabulary', [])
if not expected_vocab:
return {'passed': True, 'warnings': [], 'suggestions': []}
response_lower = response.lower()
vocab_found = sum(1 for word in expected_vocab if word.lower() in response_lower)
vocab_ratio = vocab_found / len(expected_vocab) if expected_vocab else 0
if vocab_ratio < 0.1: # 如果专业词汇使用率过低
return {
'passed': False,
'warnings': ['专业词汇使用不足'],
'suggestions': [f'建议使用更多专业术语，如：{", ".join(expected_vocab[:3])}']
}
return {'passed': True, 'warnings': [], 'suggestions': []}
def _check_tone_consistency(self, response, profile):
"""检查语调一致性"""
tone_indicators = profile.get('tone_indicators', [])
if not tone_indicators:
return {'passed': True, 'warnings': [], 'suggestions': []}
# 简化的语调检查
response_lower = response.lower()
# 检查是否包含期望的语调指示词
tone_found = any(indicator.lower() in response_lower for indicator in tone_indicators)
if not tone_found and len(response) > 50: # 对于较长回复进行检查
return {
'passed': False,
'warnings': ['语调与角色设定不符'],
'suggestions': ['建议调整语言风格以符合角色特征']
}
return {'passed': True, 'warnings': [], 'suggestions': []}
def _check_expertise_consistency(self, response, profile):
"""检查专业性一致性"""
expertise_keywords = profile.get('expertise_keywords', [])
if not expertise_keywords:
return {'passed': True, 'warnings': [], 'suggestions': []}
response_lower = response.lower()
expertise_found = any(keyword.lower() in response_lower for keyword in expertise_keywords)
# 如果回复较长但没有体现专业性
if len(response) > 100 and not expertise_found:
return {
'passed': False,
'warnings': ['回复缺乏专业性体现'],
'suggestions': ['建议增加专业知识和见解']
}
return {'passed': True, 'warnings': [], 'suggestions': []}
def _check_behavior_consistency(self, response, profile):
"""检查行为模式一致性"""
behavior_patterns = profile.get('behavior_patterns', [])
forbidden_responses = profile.get('forbidden_responses', [])
# 检查禁止的回复模式
response_lower = response.lower()
for forbidden in forbidden_responses:
if forbidden.lower() in response_lower:
return {
'passed': False,
'warnings': [f'包含不符合角色的表达：{forbidden}'],
'suggestions': ['请调整回复以符合角色设定']
}
return {'passed': True, 'warnings': [], 'suggestions': []}
# 使用示例
checker = RoleConsistencyChecker()
# 注册Python专家角色档案
python_expert_profile = {
'vocabulary': ['函数', '变量', '类', '模块', '异常', '装饰器', '生成器'],
'tone_indicators': ['建议', '推荐', '最佳实践', '需要注意'],
'expertise_keywords': ['性能', '优化', '架构', '设计模式', '测试'],
'behavior_patterns': ['提供代码示例', '解释原理', '给出建议'],
'forbidden_responses': ['我不知道', '这超出了我的能力', '我不确定']
}
checker.register_role_profile('python_expert', python_expert_profile)
# 检查回复一致性
test_response = "这是一个很好的问题。你可以使用列表推导式来优化代码性能，这是Python中的最佳实践之一。"
consistency_result = checker.check_response_consistency('python_expert', test_response)
print("一致性检查结果：")
print(f"一致性：{consistency_result['consistent']}")
if consistency_result['warnings']:
print("警告：", consistency_result['warnings'])
if consistency_result['suggestions']:
print("建议：", consistency_result['suggestions'])
高级角色扮演技巧
1. 多角色协作系统
class MultiRoleCollaboration:
"""多角色协作系统"""
def __init__(self):
self.roles = {}
self.collaboration_history = []
self.current_session = None
def register_role(self, role_name, role_config):
"""注册角色"""
self.roles[role_name] = {
'config': role_config,
'active': False,
'interaction_count': 0
}
def start_collaboration_session(self, session_name, participating_roles):
"""开始协作会话"""
self.current_session = {
'name': session_name,
'roles': participating_roles,
'start_time': time.time(),
'interactions': []
}
# 激活参与角色
for role_name in participating_roles:
if role_name in self.roles:
self.roles[role_name]['active'] = True
def generate_collaboration_prompt(self, task_description):
"""生成协作提示词"""
if not self.current_session:
return "请先开始协作会话"
active_roles = self.current_session['roles']
prompt = f"""
多角色协作任务
================
任务描述：{task_description}
参与角色：
"""
for role_name in active_roles:
if role_name in self.roles:
role_config = self.roles[role_name]['config']
prompt += f"""
{role_name}：
- 专业领域：{role_config.get('expertise', '通用')}
- 主要职责：{role_config.get('responsibility', '协助解决问题')}
- 协作方式：{role_config.get('collaboration_style', '积极参与讨论')}
"""
prompt += f"""
协作规则：
1. 每个角色按照自己的专业领域提供见解
2. 角色之间可以相互讨论和补充
3. 最终形成综合性的解决方案
4. 保持各自角色的特色和专业性
请各角色依次发表意见，然后进行讨论。
"""
return prompt
def simulate_role_interaction(self, role_name, response, target_role=None):
"""模拟角色交互"""
if not self.current_session:
return "协作会话未开始"
interaction = {
'timestamp': time.time(),
'from_role': role_name,
'to_role': target_role or 'all',
'response': response,
'interaction_type': 'direct' if target_role else 'broadcast'
}
self.current_session['interactions'].append(interaction)
self.roles[role_name]['interaction_count'] += 1
return f"[{role_name}] {response}"
def generate_summary(self):
"""生成协作总结"""
if not self.current_session:
return "无协作会话数据"
session = self.current_session
total_interactions = len(session['interactions'])
summary = f"""
协作会话总结
============
会话名称：{session['name']}
参与角色：{', '.join(session['roles'])}
交互次数：{total_interactions}
角色贡献度：
"""
for role_name in session['roles']:
role_interactions = sum(1 for i in session['interactions'] if i['from_role'] == role_name)
contribution_rate = (role_interactions / total_interactions * 100) if total_interactions > 0 else 0
summary += f"- {role_name}: {role_interactions}次交互 ({contribution_rate:.1f}%)\n"
return summary
# 使用示例
collaboration = MultiRoleCollaboration()
# 注册多个角色
roles_config = {
'architect': {
'expertise': '系统架构设计',
'responsibility': '设计整体架构方案',
'collaboration_style': '提供技术指导和架构建议'
},
'developer': {
'expertise': '代码实现',
'responsibility': '编写和优化代码',
'collaboration_style': '关注实现细节和技术可行性'
},
'tester': {
'expertise': '质量保证',
'responsibility': '测试策略和质量控制',
'collaboration_style': '从质量角度提出建议和风险提醒'
}
}
for role_name, config in roles_config.items():
collaboration.register_role(role_name, config)
# 开始协作会话
collaboration.start_collaboration_session(
'web_application_design',
['architect', 'developer', 'tester']
)
# 生成协作提示词
task = "设计一个高并发的电商网站后端系统"
prompt = collaboration.generate_collaboration_prompt(task)
print(prompt)
2. 动态角色适应
class DynamicRoleAdaptation:
"""动态角色适应系统"""
def __init__(self):
self.base_roles = {}
self.adaptation_rules = {}
self.context_analyzers = {}
def register_base_role(self, role_name, base_config):
"""注册基础角色"""
self.base_roles[role_name] = base_config
def add_adaptation_rule(self, rule_name, condition_func, adaptation_func):
"""添加适应规则"""
self.adaptation_rules[rule_name] = {
'condition': condition_func,
'adaptation': adaptation_func
}
def analyze_context(self, user_input, conversation_history):
"""分析上下文"""
context = {
'user_expertise_level': self._assess_user_expertise(user_input, conversation_history),
'topic_complexity': self._assess_topic_complexity(user_input),
'urgency_level': self._assess_urgency(user_input),
'emotional_tone': self._assess_emotional_tone(user_input),
'interaction_style': self._assess_interaction_style(conversation_history)
}
return context
def adapt_role(self, base_role_name, context):
"""根据上下文适应角色"""
if base_role_name not in self.base_roles:
return None
base_role = self.base_roles[base_role_name].copy()
adapted_role = base_role.copy()
# 应用适应规则
for rule_name, rule in self.adaptation_rules.items():
if rule['condition'](context):
adapted_role = rule['adaptation'](adapted_role, context)
return adapted_role
def _assess_user_expertise(self, user_input, history):
"""评估用户专业水平"""
# 简化的专业水平评估
technical_terms = ['算法', '架构', '设计模式', '优化', '性能', '并发', '异步']
term_count = sum(1 for term in technical_terms if term in user_input)
if term_count >= 3:
return 'expert'
elif term_count >= 1:
return 'intermediate'
else:
return 'beginner'
def _assess_topic_complexity(self, user_input):
"""评估话题复杂度"""
complex_indicators = ['复杂', '高级', '深入', '详细', '全面', '系统']
if any(indicator in user_input for indicator in complex_indicators):
return 'high'
elif len(user_input) > 100:
return 'medium'
else:
return 'low'
def _assess_urgency(self, user_input):
"""评估紧急程度"""
urgent_indicators = ['紧急', '急需', '马上', '立即', '尽快']
if any(indicator in user_input for indicator in urgent_indicators):
return 'high'
else:
return 'normal'
def _assess_emotional_tone(self, user_input):
"""评估情感基调"""
positive_indicators = ['谢谢', '感谢', '很好', '棒', '优秀']
negative_indicators = ['困惑', '不懂', '难', '问题', '错误']
positive_count = sum(1 for indicator in positive_indicators if indicator in user_input)
negative_count = sum(1 for indicator in negative_indicators if indicator in user_input)
if positive_count > negative_count:
return 'positive'
elif negative_count > positive_count:
return 'negative'
else:
return 'neutral'
def _assess_interaction_style(self, history):
"""评估交互风格"""
if not history:
return 'formal'
# 分析历史对话的风格
casual_indicators = ['哈哈', '嗯', '好的', '行']
formal_indicators = ['请', '您', '感谢', '谢谢']
recent_messages = history[-3:] if len(history) >= 3 else history
casual_count = sum(1 for msg in recent_messages
for indicator in casual_indicators
if indicator in msg.get('user_input', ''))
return 'casual' if casual_count > 0 else 'formal'
# 使用示例
adapter = DynamicRoleAdaptation()
# 注册基础Python专家角色
base_python_expert = {
'name': 'Python专家',
'expertise_level': 'high',
'communication_style': 'technical',
'detail_level': 'medium',
'examples_count': 2,
'explanation_depth': 'medium'
}
adapter.register_base_role('python_expert', base_python_expert)
# 添加适应规则
def beginner_adaptation_condition(context):
return context['user_expertise_level'] == 'beginner'
def beginner_adaptation_function(role, context):
"""为初学者调整角色"""
role['communication_style'] = 'simple'
role['detail_level'] = 'high'
role['examples_count'] = 3
role['explanation_depth'] = 'basic'
return role
adapter.add_adaptation_rule(
'beginner_friendly',
beginner_adaptation_condition,
beginner_adaptation_function
)
def urgent_adaptation_condition(context):
return context['urgency_level'] == 'high'
def urgent_adaptation_function(role, context):
"""为紧急情况调整角色"""
role['communication_style'] = 'direct'
role['detail_level'] = 'low'
role['examples_count'] = 1
return role
adapter.add_adaptation_rule(
'urgent_response',
urgent_adaptation_condition,
urgent_adaptation_function
)
# 模拟使用
user_input = "我是Python新手，请帮我解释什么是函数"
conversation_history = []
context = adapter.analyze_context(user_input, conversation_history)
adapted_role = adapter.adapt_role('python_expert', context)
print("原始角色配置：", base_python_expert)
print("适应后角色配置：", adapted_role)
print("上下文分析：", context)
性能优化与调试
1. 角色性能监控
class RolePerformanceMonitor:
"""角色性能监控器"""
def __init__(self):
self.metrics = {}
self.performance_history = []
self.alert_thresholds = {
'response_time': 5.0, # 秒
'consistency_score': 0.7, # 一致性分数
'user_satisfaction': 3.0, # 用户满意度(1-5)
'error_rate': 0.1 # 错误率
}
def record_interaction(self, role_name, interaction_data):
"""记录交互数据"""
if role_name not in self.metrics:
self.metrics[role_name] = {
'total_interactions': 0,
'total_response_time': 0,
'consistency_scores': [],
'satisfaction_scores': [],
'error_count': 0,
'last_updated': time.time()
}
metrics = self.metrics[role_name]
metrics['total_interactions'] += 1
metrics['total_response_time'] += interaction_data.get('response_time', 0)
if 'consistency_score' in interaction_data:
metrics['consistency_scores'].append(interaction_data['consistency_score'])
if 'satisfaction_score' in interaction_data:
metrics['satisfaction_scores'].append(interaction_data['satisfaction_score'])
if interaction_data.get('has_error', False):
metrics['error_count'] += 1
metrics['last_updated'] = time.time()
# 检查性能警报
self._check_performance_alerts(role_name)
def _check_performance_alerts(self, role_name):
"""检查性能警报"""
metrics = self.metrics[role_name]
alerts = []
# 检查平均响应时间
if metrics['total_interactions'] > 0:
avg_response_time = metrics['total_response_time'] / metrics['total_interactions']
if avg_response_time > self.alert_thresholds['response_time']:
alerts.append(f"响应时间过长: {avg_response_time:.2f}秒")
# 检查一致性分数
if metrics['consistency_scores']:
avg_consistency = sum(metrics['consistency_scores']) / len(metrics['consistency_scores'])
if avg_consistency < self.alert_thresholds['consistency_score']:
alerts.append(f"一致性分数过低: {avg_consistency:.2f}")
# 检查用户满意度
if metrics['satisfaction_scores']:
avg_satisfaction = sum(metrics['satisfaction_scores']) / len(metrics['satisfaction_scores'])
if avg_satisfaction < self.alert_thresholds['user_satisfaction']:
alerts.append(f"用户满意度过低: {avg_satisfaction:.1f}")
# 检查错误率
error_rate = metrics['error_count'] / metrics['total_interactions']
if error_rate > self.alert_thresholds['error_rate']:
alerts.append(f"错误率过高: {error_rate:.1%}")
if alerts:
self._trigger_alerts(role_name, alerts)
def _trigger_alerts(self, role_name, alerts):
"""触发性能警报"""
alert_message = f"角色 {role_name} 性能警报:\n" + "\n".join(f"- {alert}" for alert in alerts)
print(f"⚠️ {alert_message}")
# 记录警报历史
self.performance_history.append({
'timestamp': time.time(),
'role_name': role_name,
'alert_type': 'performance',
'alerts': alerts
})
def generate_performance_report(self, role_name=None):
"""生成性能报告"""
if role_name and role_name in self.metrics:
return self._generate_single_role_report(role_name)
else:
return self._generate_overall_report()
def _generate_single_role_report(self, role_name):
"""生成单个角色的性能报告"""
metrics = self.metrics[role_name]
# 计算各项指标
total_interactions = metrics['total_interactions']
avg_response_time = (metrics['total_response_time'] / total_interactions) if total_interactions > 0 else 0
avg_consistency = (sum(metrics['consistency_scores']) / len(metrics['consistency_scores'])) if metrics['consistency_scores'] else 0
avg_satisfaction = (sum(metrics['satisfaction_scores']) / len(metrics['satisfaction_scores'])) if metrics['satisfaction_scores'] else 0
error_rate = (metrics['error_count'] / total_interactions) if total_interactions > 0 else 0
report = f"""
角色性能报告 - {role_name}
========================
基础指标：
- 总交互次数: {total_interactions}
- 平均响应时间: {avg_response_time:.2f}秒
- 错误率: {error_rate:.1%}
质量指标：
- 平均一致性分数: {avg_consistency:.2f}/1.0
- 平均用户满意度: {avg_satisfaction:.1f}/5.0
性能评级：
{self._calculate_performance_grade(avg_response_time, avg_consistency, avg_satisfaction, error_rate)}
优化建议：
{self._generate_optimization_suggestions(role_name, avg_response_time, avg_consistency, avg_satisfaction, error_rate)}
"""
return report
def _generate_overall_report(self):
"""生成整体性能报告"""
if not self.metrics:
return "暂无性能数据"
report = "整体性能报告\n" + "="*20 + "\n\n"
for role_name in self.metrics:
metrics = self.metrics[role_name]
total_interactions = metrics['total_interactions']
avg_response_time = (metrics['total_response_time'] / total_interactions) if total_interactions > 0 else 0
error_rate = (metrics['error_count'] / total_interactions) if total_interactions > 0 else 0
report += f"{role_name}:\n"
report += f" - 交互次数: {total_interactions}\n"
report += f" - 平均响应时间: {avg_response_time:.2f}秒\n"
report += f" - 错误率: {error_rate:.1%}\n\n"
return report
def _calculate_performance_grade(self, response_time, consistency, satisfaction, error_rate):
"""计算性能等级"""
score = 0
# 响应时间评分 (30%)
if response_time <= 2.0:
score += 30
elif response_time <= 3.0:
score += 25
elif response_time <= 5.0:
score += 20
else:
score += 10
# 一致性评分 (25%)
score += consistency * 25
# 用户满意度评分 (25%)
score += (satisfaction / 5.0) * 25
# 错误率评分 (20%)
if error_rate <= 0.05:
score += 20
elif error_rate <= 0.1:
score += 15
elif error_rate <= 0.2:
score += 10
else:
score += 5
if score >= 90:
return "A+ (优秀)"
elif score >= 80:
return "A (良好)"
elif score >= 70:
return "B (一般)"
elif score >= 60:
return "C (需要改进)"
else:
return "D (急需优化)"
def _generate_optimization_suggestions(self, role_name, response_time, consistency, satisfaction, error_rate):
"""生成优化建议"""
suggestions = []
if response_time > 3.0:
suggestions.append("- 优化提示词长度，减少不必要的描述")
suggestions.append("- 简化角色设定，专注核心功能")
if consistency < 0.8:
suggestions.append("- 加强角色一致性检查机制")
suggestions.append("- 完善角色档案和行为约束")
if satisfaction < 4.0:
suggestions.append("- 改进回复质量和实用性")
suggestions.append("- 增加个性化和互动性")
if error_rate > 0.1:
suggestions.append("- 加强错误处理和异常情况应对")
suggestions.append("- 完善角色知识库和能力边界")
return "\n".join(suggestions) if suggestions else "- 当前性能良好，继续保持"
# 使用示例
monitor = RolePerformanceMonitor()
# 模拟记录交互数据
interaction_data = [
{'response_time': 2.5, 'consistency_score': 0.9, 'satisfaction_score': 4.5, 'has_error': False},
{'response_time': 3.2, 'consistency_score': 0.8, 'satisfaction_score': 4.0, 'has_error': False},
{'response_time': 6.1, 'consistency_score': 0.6, 'satisfaction_score': 3.0, 'has_error': True},
]
for data in interaction_data:
monitor.record_interaction('python_expert', data)
# 生成性能报告
report = monitor.generate_performance_report('python_expert')
print(report)
实战项目开发
项目：智能编程助手
class IntelligentCodingAssistant:
"""智能编程助手"""
def __init__(self):
self.role_engine = RolePlayingEngine()
self.memory_system = ContextMemorySystem()
self.consistency_checker = RoleConsistencyChecker()
self.performance_monitor = RolePerformanceMonitor()
# 初始化编程相关角色
self._initialize_coding_roles()
def _initialize_coding_roles(self):
"""初始化编程相关角色"""
# Python专家
python_expert = {
'profession': 'Python高级开发工程师',
'expertise': ['Python编程', '代码优化', '框架开发', '最佳实践'],
'personality': {
'严谨': '注重代码质量和规范',
'耐心': '善于解释复杂概念',
'实用': '提供可行的解决方案'
},
'communication_style': '技术准确、逻辑清晰、示例丰富',
'knowledge_base': [
'精通Python 3.x所有特性',
'熟悉Django、Flask、FastAPI等框架',
'了解性能优化和调试技巧',
'掌握测试驱动开发'
],
'constraints': [
'只提供Python相关的建议',
'代码示例必须可运行',
'遵循PEP 8编码规范'
]
}
# 代码审查专家
code_reviewer = {
'profession': '代码审查专家',
'expertise': ['代码质量', '安全审查', '性能分析', '架构评估'],
'personality': {
'细致': '关注代码细节和潜在问题',
'客观': '提供公正的评价和建议',
'建设性': '给出具体的改进方案'
},
'communication_style': '专业客观、条理清晰、建议具体',
'knowledge_base': [
'多语言代码审查经验',
'安全漏洞识别能力',
'性能瓶颈分析技能',
'代码质量评估标准'
],
'constraints': [
'必须提供具体的改进建议',
'指出问题的严重程度',
'给出修改后的示例代码'
]
}
# 架构师
architect = {
'profession': '软件架构师',
'expertise': ['系统设计', '架构模式', '技术选型', '扩展性设计'],
'personality': {
'全局': '从整体角度思考问题',
'前瞻': '考虑长期发展和扩展',
'平衡': '在各种因素间找到最佳平衡'
},
'communication_style': '高屋建瓴、逻辑严密、考虑全面',
'knowledge_base': [
'各种架构模式和设计原则',
'分布式系统设计经验',
'技术选型和评估能力',
'性能和扩展性优化'
],
'constraints': [
'必须考虑系统的可扩展性',
'提供架构图和设计说明',
'评估技术方案的优缺点'
]
}
# 注册角色
self.role_engine.define_role('python_expert', python_expert)
self.role_engine.define_role('code_reviewer', code_reviewer)
self.role_engine.define_role('architect', architect)
# 注册一致性检查档案
self._register_consistency_profiles()
def _register_consistency_profiles(self):
"""注册一致性检查档案"""
# Python专家档案
python_profile = {
'vocabulary': ['函数', '类', '模块', '装饰器', '生成器', '异常', '列表推导'],
'tone_indicators': ['建议', '推荐', '最佳实践', '需要注意', '可以考虑'],
'expertise_keywords': ['性能', '优化', 'Pythonic', '可读性', '维护性'],
'behavior_patterns': ['提供代码示例', '解释原理', '给出最佳实践'],
'forbidden_responses': ['我不知道', '这超出了我的能力']
}
# 代码审查专家档案
reviewer_profile = {
'vocabulary': ['代码质量', '重构', '漏洞', '性能', '可维护性', '测试覆盖'],
'tone_indicators': ['发现问题', '建议改进', '需要修复', '可以优化'],
'expertise_keywords': ['安全', '性能', '质量', '规范', '最佳实践'],
'behavior_patterns': ['指出具体问题', '提供改进建议', '给出示例代码'],
'forbidden_responses': ['代码看起来不错', '没有问题']
}
self.consistency_checker.register_role_profile('python_expert', python_profile)
self.consistency_checker.register_role_profile('code_reviewer', reviewer_profile)
def process_coding_request(self, user_input, preferred_role='python_expert'):
"""
处理编程请求
Args:
user_input: 用户输入
preferred_role: 首选角色
Returns:
处理结果
"""
start_time = time.time()
try:
# 生成角色提示词
prompt = self.role_engine.generate_role_prompt(preferred_role, user_input)
# 获取上下文信息
context_prompt = self.memory_system.generate_context_prompt(preferred_role)
if context_prompt:
prompt += f"\n\n上下文信息：{context_prompt}"
# 模拟AI回复（实际应用中这里会调用AI API）
ai_response = self._simulate_ai_response(preferred_role, user_input)
# 检查回复一致性
consistency_result = self.consistency_checker.check_response_consistency(
preferred_role, ai_response
)
# 记录交互
response_time = time.time() - start_time
self.memory_system.add_interaction(user_input, ai_response, preferred_role)
# 记录性能数据
performance_data = {
'response_time': response_time,
'consistency_score': 1.0 if consistency_result['consistent'] else 0.7,
'satisfaction_score': 4.5, # 实际应用中由用户评分
'has_error': not consistency_result['consistent']
}
self.performance_monitor.record_interaction(preferred_role, performance_data)
return {
'role': preferred_role,
'prompt': prompt,
'response': ai_response,
'consistency': consistency_result,
'response_time': response_time
}
except Exception as e:
# 记录错误
error_data = {
'response_time': time.time() - start_time,
'consistency_score': 0,
'satisfaction_score': 1,
'has_error': True
}
self.performance_monitor.record_interaction(preferred_role, error_data)
return {
'error': str(e),
'role': preferred_role,
'response_time': time.time() - start_time
}
def _simulate_ai_response(self, role, user_input):
"""模拟AI回复（实际应用中替换为真实AI API调用）"""
responses = {
'python_expert': {
'函数': """
Python函数是可重用的代码块，用于执行特定任务。以下是函数的基本语法：
```python
def function_name(parameters):
\"\"\"函数文档字符串\"\"\"
# 函数体
return result
```
示例：
```python
def calculate_area(length, width):
\"\"\"计算矩形面积\"\"\"
return length * width
# 调用函数
area = calculate_area(5, 3)
print(f"面积是: {area}")
```
最佳实践：
1. 使用描述性的函数名
2. 添加文档字符串说明函数用途
3. 保持函数功能单一
4. 使用类型提示提高代码可读性
""",
'优化': """
Python代码优化可以从以下几个方面入手：
1. **算法优化**：
```python
# 低效的方式
def find_duplicates_slow(lst):
duplicates = []
for i in range(len(lst)):
for j in range(i+1, len(lst)):
if lst[i] == lst[j] and lst[i] not in duplicates:
duplicates.append(lst[i])
return duplicates
# 高效的方式
def find_duplicates_fast(lst):
seen = set()
duplicates = set()
for item in lst:
if item in seen:
duplicates.add(item)
else:
seen.add(item)
return list(duplicates)
```
2. **使用内置函数和库**
3. **列表推导式替代循环**
4. **生成器节省内存**
"""
},
'code_reviewer': {
'审查': """
代码审查发现以下问题：
**严重问题：**
❌ 缺少异常处理
❌ 函数缺少文档字符串
❌ 变量命名不规范
**改进建议：**
💡 添加类型提示
💡 使用更Pythonic的写法
💡 增加单元测试
**修改后的代码示例：**
```python
def improved_function(data: List[str]) -> Dict[str, int]:
\"\"\"改进后的函数，包含错误处理和类型提示\"\"\"
try:
result = {}
for item in data:
result[item] = result.get(item, 0) + 1
return result
except Exception as e:
logger.error(f"处理数据时出错: {e}")
raise
```
"""
}
}
# 简单的关键词匹配
for keyword, response in responses.get(role, {}).items():
if keyword in user_input:
return response
# 默认回复
return f"作为{role}，我理解您的问题。让我为您提供专业的建议..."
def get_performance_summary(self):
"""获取性能摘要"""
return self.performance_monitor.generate_performance_report()
def switch_role(self, new_role, context=""):
"""切换角色"""
if new_role in ['python_expert', 'code_reviewer', 'architect']:
return f"已切换到{new_role}角色。{context}"
else:
return "不支持的角色类型"
# 使用示例
assistant = IntelligentCodingAssistant()
# 测试Python专家角色
result1 = assistant.process_coding_request("请解释Python函数的用法", "python_expert")
print("Python专家回复：")
print(result1['response'])
print(f"响应时间：{result1['response_time']:.2f}秒")
print(f"一致性检查：{result1['consistency']['consistent']}")
print()
# 测试代码审查角色
result2 = assistant.process_coding_request("请审查这段代码的质量", "code_reviewer")
print("代码审查专家回复：")
print(result2['response'])
print()
# 获取性能报告
performance_report = assistant.get_performance_summary()
print("性能报告：")
print(performance_report)
总结与展望
关键技术要点
- 角色定义的完整性：包括专业身份、知识体系、性格特征和行为约束
- 一致性维护机制：通过上下文记忆和一致性检查确保角色稳定性
- 动态适应能力：根据用户水平和情境调整角色表现
- 性能监控体系：实时跟踪角色表现并提供优化建议
技术发展趋势
最佳实践总结
best_practices = {
"角色设计": [
"明确角色的专业边界和能力范围",
"设计一致的性格特征和沟通风格",
"建立完整的知识体系和经验背景",
"定义清晰的行为约束和禁止事项"
],
"实现技巧": [
"使用模板化的提示词结构",
"实现上下文记忆和状态管理",
"建立角色一致性检查机制",
"设计性能监控和优化系统"
],
"质量保证": [
"定期评估角色表现质量",
"收集用户反馈并持续改进",
"进行A/B测试优化角色设定",
"建立错误处理和异常恢复机制"
],
"扩展发展": [
"支持多角色协作和切换",
"实现动态角色适应和学习",
"集成外部知识库和工具",
"开发角色个性化定制功能"
]
}
for category, practices in best_practices.items():
print(f"{category}:")
for practice in practices:
print(f" ✓ {practice}")
print()
未来发展方向
- 多模态角色扮演：结合语音、图像、视频等多种模态
- 情感智能角色：具备情感理解和表达能力的AI角色
- 个性化角色定制：根据用户偏好自动调整角色特征
- 协作智能系统：多个AI角色协同工作解决复杂问题
扩展阅读
作者简介：AI系统架构师，专注于角色扮演技术和智能对话系统开发，在AI角色设计和优化方面有丰富经验。
版权声明：本文为原创技术文章，转载请注明出处。
更新时间：2024年7月14日
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
