内容纲要
复杂AI交互模式实战（详解版）
目标：精通复杂AI交互模式、场景设计、工程落地
目录
交互模式概述
1. 复杂交互特征
【与简单交互的区别】
维度 | 简单交互 | 复杂交互
------------|-------------------|------------------
目标 | 单一响应 | 多目标协作
角色 | 单一AI | 多AI角色
状态 | 无状态 | 复杂状态机
流程 | 线性流程 | 非线性分支
反馈 | 直接反馈 | 多维反馈
记忆 | 短期记忆 | 长期记忆
上下文 | 简单上下文 | 多层级上下文
【复杂交互类型】
1. 协作型
- 多角色协作
- 共同完成任务
- 群体决策
2. 竞争型
- 对立角色
- 策略博弈
- 胜负判断
3. 教学型
- 师生互动
- 知识传递
- 能力评估
4. 游戏化
- 游戏规则
- 玩家系统
- 社交互动
5. 模拟型
- 场景模拟
- 行为预测
- 决策推演2. 设计原则
【可用性原则】
1. 明确引导
- 清晰的提示
- 明确的反馈
- 可操作的选项
2. 合理流程
- 符合直觉
- 可预测行为
- 支持回退
3. 错误容忍
- 容错处理
- 友好提示
- 恢复机制
【沉浸感原则】
1. 角色一致性
- 保持性格
- 记忆过往
- 情感连续
2. 自然对话
- 人类化表达
- 上下文连贯
- 情感表达
3. 场景真实
- 环境细节
- 动态变化
- 时间推进
【可扩展性原则】
1. 模块化设计
- 角色可替换
- 规则可配置
- 内容可扩展
2. 数据驱动
- 配置外部化
- 规则数据化
- 模板化
3. 性能优化
- 异步处理
- 缓存策略
- 资源管理协作型交互
1. 头脑风暴系统
from typing import List, Dict
from dataclasses import dataclass
import random
@dataclass
class BrainstormSession:
"""头脑风暴会话"""
topic: str # 头脑风暴主题
participants: List[Dict] # 参与者
rounds: int = 3 # 轮数
ideas_per_round: int = 2 # 每轮创意数
def __post_init__(self):
self.all_ideas = []
self.feedback_history = []
self.final_ideas = []
def run(self) -> Dict:
"""运行头脑风暴"""
print(f"\n{'='*50}")
print(f"头脑风暴主题：{self.topic}")
print(f"{'='*50}\n")
for round_num in range(self.rounds):
print(f"\n{'─'*20}")
print(f"第 {round_num + 1} 轮头脑风暴")
print(f"{'─'*20}\n")
# 1. 生成创意
round_ideas = self.generate_ideas(round_num)
self.all_ideas.extend(round_ideas)
# 2. 收集反馈
self.collect_feedback(round_ideas)
# 3. 创意整合
if round_num < self.rounds - 1:
self.synthesize_ideas()
# 4. 最终评估
self.final_ideas = self.evaluate_and_rank()
return {
"topic": self.topic,
"total_ideas": len(self.all_ideas),
"final_ideas": self.final_ideas
}
def generate_ideas(self, round_num: int) -> List[Dict]:
"""生成创意"""
ideas = []
for participant in self.participants:
for i in range(self.ideas_per_round):
# 生成创意
idea = self._generate_single_idea(
participant,
self.all_ideas,
round_num
)
ideas.append({
"id": f"{participant['id']}_round{round_num}_{i}",
"participant": participant['name'],
"content": idea,
"round": round_num + 1,
"votes": 0
})
print(f"{participant['name']}: {idea}")
return ideas
def _generate_single_idea(self, participant: Dict,
existing_ideas: List[Dict],
round_num: int) -> str:
"""生成单个创意"""
existing_text = "\n".join([
f"- {idea['content']}"
for idea in existing_ideas[-5:] # 只考虑最近5个
]) if existing_ideas else "暂无"
prompt = f"""
你是{participant['name']}，{participant['role']}。
你的特点：{participant['style']}
头脑风暴主题：{self.topic}
之前提出的创意：
{existing_text}
请提供一个独特、有创意的想法：
- 避免重复之前的想法
- 符合你的角色特点
- 具有可行性和创新性
- 回答要简洁明了（1-2句话）
"""
# 调用LLM生成
return self.llm_generate(prompt)
def collect_feedback(self, ideas: List[Dict]):
"""收集反馈"""
print(f"\n【反馈阶段】\n")
for participant in self.participants:
feedback = self._generate_feedback(participant, ideas)
self.feedback_history.append({
"participant": participant['name'],
"feedback": feedback
})
print(f"{participant['name']}的反馈：{feedback}\n")
def _generate_feedback(self, participant: Dict,
ideas: List[Dict]) -> str:
"""生成反馈"""
ideas_text = "\n".join([
f"{i+1}. {idea['participant']}: {idea['content']}"
for i, idea in enumerate(ideas)
])
prompt = f"""
你是{participant['name']}，{participant['role']}。
请对以下创意提供反馈：
{ideas_text}
反馈要求：
- 指出最值得关注的创意
- 分析创意的优缺点
- 提出改进建议
- 保持客观和专业
"""
return self.llm_generate(prompt)
def synthesize_ideas(self):
"""整合创意"""
print(f"\n【创意整合】\n")
latest_ideas = self.all_ideas[-len(self.participants) * self.ideas_per_round:]
synthesis = self._generate_synthesis(latest_ideas)
print(f"综合观点：{synthesis}\n")
def _generate_synthesis(self, ideas: List[Dict]) -> str:
"""生成综合观点"""
prompt = f"""
请综合评估以下创意，提炼出最有价值的方向：
{self._format_ideas(ideas)}
请提供：
1. 共同趋势
2. 创新突破点
3. 值得深入的方向
"""
return self.llm_generate(prompt)
def evaluate_and_rank(self) -> List[Dict]:
"""评估并排序"""
print(f"\n{'='*20}")
print("最终评估与排序")
print(f"{'='*20}\n")
# 交叉评分
for idea in self.all_ideas:
idea["score"] = self._cross_evaluate(idea)
# 排序
ranked = sorted(self.all_ideas, key=lambda x: x["score"], reverse=True)
# 展示结果
for i, idea in enumerate(ranked[:5], 1):
print(f"{i}. {idea['content']} (评分: {idea['score']:.2f})")
return ranked[:5]
def _cross_evaluate(self, idea: Dict) -> float:
"""交叉评估"""
scores = []
for participant in self.participants:
score = self._evaluate_idea(participant, idea)
scores.append(score)
return sum(scores) / len(scores)
# 使用示例
def run_brainstorm():
"""运行头脑风暴"""
# 定义参与者
participants = [
{
"id": "p1",
"name": "产品专家",
"role": "产品经理",
"style": "善于从用户角度思考，关注市场需求"
},
{
"id": "p2",
"name": "技术顾问",
"role": "技术专家",
"style": "关注技术可行性，善于提出创新方案"
},
{
"id": "p3",
"name": "设计师",
"role": "UI/UX设计师",
"style": "注重用户体验，擅长提出视觉创意"
},
{
"id": "p4",
"name": "运营总监",
"role": "运营专家",
"style": "关注落地效果，善于发现商业价值"
}
]
# 创建会话
session = BrainstormSession(
topic="如何提升电商平台的用户留存率？",
participants=participants,
rounds=3,
ideas_per_round=2
)
# 运行
result = session.run()
return result2. 项目协作模拟
@dataclass
class ProjectCollaboration:
"""项目协作模拟"""
project_name: str
roles: Dict[str, AICharacter]
communication_log: List[Dict] = None
def __post_init__(self):
self.communication_log = []
self.project_state = {
"requirements": [],
"design": None,
"implementation": [],
"reviews": []
}
def simulate_development(self, user_request: str) -> Dict:
"""模拟开发过程"""
print(f"\n{'='*50}")
print(f"项目：{self.project_name}")
print(f"需求：{user_request}")
print(f"{'='*50}\n")
# 阶段1：需求分析
print("\n【阶段1：需求分析】")
requirements = self._analyze_requirements(user_request)
self.project_state["requirements"] = requirements
# 阶段2：技术设计
print("\n【阶段2：技术设计】")
design = self._technical_design(requirements)
self.project_state["design"] = design
# 阶段3：迭代开发
print("\n【阶段3：迭代开发】")
iterations = 3
for i in range(iterations):
print(f"\n--- 第 {i + 1} 轮迭代 ---")
code = self._implement_feature(design, i)
self.project_state["implementation"].append(code)
# 代码审查
review = self._code_review(code)
self.project_state["reviews"].append(review)
if review["approved"]:
print("✓ 代码审查通过")
else:
print("✗ 代码需要修改")
# 基于反馈修改代码
code = self._refine_code(code, review["feedback"])
# 阶段4：最终验收
print("\n【阶段4：最终验收】")
acceptance = self._final_acceptance()
return {
"project": self.project_name,
"requirements": requirements,
"design": design,
"implementation": self.project_state["implementation"],
"acceptance": acceptance
}
def _analyze_requirements(self, user_request: str) -> Dict:
"""需求分析"""
pm = self.roles["product_manager"]
tech_lead = self.roles["tech_lead"]
# 产品经理分析需求
pm_analysis = self._ask_character(pm, f"""
作为产品经理，请详细分析以下用户需求：
{user_request}
请提供：
1. 核心目标
2. 功能需求清单
3. 非功能性需求（性能、安全等）
4. 优先级排序
""")
print(f"\n{pm.name}的需求分析：")
print(pm_analysis)
# 技术负责人评估
tech_assessment = self._ask_character(tech_lead, f"""
作为技术负责人，请评估以下需求的技术可行性：
{pm_analysis}
请提供：
1. 技术选型建议
2. 潜在技术风险
3. 开发工时预估
4. 架构建议
""")
print(f"\n{tech_lead.name}的技术评估：")
print(tech_assessment)
return {
"pm_analysis": pm_analysis,
"tech_assessment": tech_assessment
}
def _technical_design(self, requirements: Dict) -> Dict:
"""技术设计"""
architect = self.roles["architect"]
developer = self.roles["developer"]
# 架构师设计方案
architecture = self._ask_character(architect, f"""
作为架构师，基于以下需求和评估，设计技术方案：
{requirements['pm_analysis']}
{requirements['tech_assessment']}
请提供：
1. 系统架构图描述
2. 模块划分
3. 接口设计
4. 数据库设计
5. 部署方案
""")
print(f"\n{architect.name}的架构设计：")
print(architecture)
# 开发者反馈
dev_feedback = self._ask_character(developer, f"""
作为开发者，请评估以下技术方案：
{architecture}
请提供：
1. 实现可行性
2. 潜在问题
3. 优化建议
""")
print(f"\n{developer.name}的反馈：")
print(dev_feedback)
return {
"architecture": architecture,
"feedback": dev_feedback
}
def _implement_feature(self, design: Dict, iteration: int) -> str:
"""实现功能"""
developer = self.roles["developer"]
prompt = f"""
作为开发者，基于以下技术设计实现代码：
{design['architecture']}
这是第 {iteration + 1} 轮迭代。
要求：
1. 代码质量高
2. 遵循最佳实践
3. 包含必要的注释
4. 考虑错误处理
"""
code = self._ask_character(developer, prompt)
return code
def _code_review(self, code: str) -> Dict:
"""代码审查"""
reviewer = self.roles["code_reviewer"]
prompt = f"""
作为代码审查者，请审查以下代码：
{code}
请评估：
1. 代码质量（满分10分）
2. 潜在bug
3. 性能问题
4. 安全隐患
5. 改进建议
最终结论：通过 / 需要修改
"""
review = self._ask_character(reviewer, prompt)
is_approved = "通过" in review
return {
"review": review,
"feedback": review,
"approved": is_approved
}竞争型交互
1. 辩论系统
@dataclass
class DebateSystem:
"""辩论系统"""
topic: str
pro_side: AICharacter # 正方
con_side: AICharacter # 反方
judge: AICharacter # 评判
rounds: int = 3
time_limit: int = 300 # 每轮时间限制（秒）
def run_debate(self) -> Dict:
"""运行辩论"""
print(f"\n{'='*50}")
print(f"辩论主题：{self.topic}")
print(f"{'='*50}")
print(f"\n正方：{self.pro_side.name}")
print(f"反方：{self.con_side.name}")
print(f"评判：{self.judge.name}\n")
debate_history = []
for round_num in range(self.rounds):
print(f"\n{'─'*20}")
print(f"第 {round_num + 1} 轮辩论")
print(f"{'─'*20}\n")
# 正方发言
pro_arg = self._generate_argument(
speaker=self.pro_side,
opponent=self.concon_side,
topic=self.topic,
previous_args=[h['con_arg'] for h in debate_history],
position="支持"
)
print(f"\n【正方】{self.pro_side.name}：")
print(pro_arg)
# 反方发言
con_arg = self._generate_argument(
speaker=self.con_side,
opponent=self.pro_side,
topic=self.topic,
previous_args=[h['pro_arg'] for h in debate_history],
position="反对"
)
print(f"\n【反方】{self.con_side.name}：")
print(con_arg)
# 记录轮次
debate_history.append({
"round": round_num + 1,
"pro_arg": pro_arg,
"con_arg": con_arg
})
# 最终评判
print(f"\n{'='*20}")
print("最终评判")
print(f"{'='*20}\n")
judgment = self._final_judgment(debate_history)
return {
"topic": self.topic,
"debate_history": debate_history,
"judgment": judgment
}
def _generate_argument(self, speaker: AICharacter,
opponent: AICharacter,
topic: str,
previous_args: List[str],
position: str) -> str:
"""生成辩论论点"""
previous_args_text = "\n".join([
f"{i+1}. {arg}"
for i, arg in enumerate(previous_args[-3:]) # 只考虑最近3个
]) if previous_args else "暂无"
prompt = f"""
你是{speaker.name}，{speaker.role}。
辩题：{topic}
你的立场：{position}该议题
对手的主要论点：
{previous_args_text}
请提供强有力的论点：
1. 提出你的核心论点
2. 回应对手的论点
3. 使用事实和逻辑支持
4. 保持专业和礼貌
5. 回答要清晰有力（200-300字）
"""
return self._ask_character(speaker, prompt)
def _final_judgment(self, debate_history: List[Dict]) -> Dict:
"""最终评判"""
debate_text = "\n\n".join([
f"""
第{h['round']}轮：
正方：{h['pro_arg']}
反方：{h['con_arg']}
"""
for h in debate_history
])
prompt = f"""
作为评判，请对以下辩论进行公正评判：
辩题：{self.topic}
辩论过程：
{debate_text}
请从以下角度评判：
1. 论点质量（满分10分）
- 论据是否充分
- 逻辑是否严密
- 事实是否准确
2. 反驳能力（满分10分）
- 是否有效回应对方
- 反驳是否有力
- 是否抓住对方弱点
3. 表达能力（满分10分）
- 表达是否清晰
- 论证是否有力
- 语气是否得体
请分别给出正方和反方的评分，
并给出最终判断（正方胜 / 反方胜 / 平局）。
请用以下格式回答：
正方评分：<总分30分>
反方评分：<总分30分>
判决：<胜方>
评判理由：<详细说明>
"""
judgment = self._ask_character(self.judge, prompt)
print(judgment)
return {
"judgment_text": judgment,
"winner": self._extract_winner(judgment),
"reasoning": self._extract_reasoning(judgment)
}2. 策略博弈
import random
class StrategyGame:
"""策略博弈系统"""
def __init__(self, player1: AICharacter, player2: AICharacter):
self.players = [player1, player2]
self.game_state = {}
self.move_history = []
def play_game(self, game_type: str = "prisoners_dilemma") -> Dict:
"""进行策略博弈"""
if game_type == "prisoners_dilemma":
return self._prisoners_dilemma()
elif game_type == "rock_paper_scissors":
return self._rock_paper_scissors()
else:
raise ValueError(f"未知游戏类型: {game_type}")
def _prisoners_dilemma(self) -> Dict:
"""囚徒困境"""
print(f"\n{'='*40}")
print("囚徒困境博弈")
print(f"{'='*40}\n")
# 描述游戏
game_description = """
游戏规则：
1. 两名囚犯被分开审讯
2. 每个囚犯可以选择：合作(C)或背叛(D)
3. 如果都合作：各判1年
4. 如果都背叛：各判5年
5. 如果一方合作背叛：合作者判10年，背叛者释放
每个囚犯不知道对方的选择。
"""
print(game_description)
# 玩家1思考
print(f"\n{self.players[0].name}正在思考...")
move1 = self._get_prisoners_move(self.players[0])
# 玩家2思考
print(f"\n{self.players[1].name}正在思考...")
move2 = self._get_prisoners_move(self.players[1])
# 揭晓结果
print(f"\n{'─'*20}")
print("揭晓结果")
print(f"{'─'*20}\n")
print(f"{self.players[0].name}选择：{move1}")
print(f"{self.players[1].name}选择：{move2}\n")
# 计算结果
outcome = self._calculate_prisoners_outcome(move1, move2)
print(outcome["result"])
print(f"\n{outcome['analysis']}")
return {
"player1_move": move1,
"player2_move": move2,
"outcome": outcome
}
def _get_prisoners_move(self, player: AICharacter) -> str:
"""获取囚徒选择"""
prompt = f"""
你是{player.name}，正在参与囚徒困境游戏。
游戏规则：
- 如果你和对方都选择合作(C)：各判1年
- 如果你和对方都选择背叛(D)：各判5年
- 如果你选择合作而对方背叛：你判10年，对方释放
- 如果你选择背叛而对方合作：你释放，对方判10年
你的角色特点：{player.personality}
作为理性人，你会选择合作(C)还是背叛(D)？
请只回答C或D，并简要说明理由。
"""
response = self._ask_character(player, prompt)
return response[0].upper() # 提取第一个字符
def _calculate_prisoners_outcome(self, move1: str, move2: str) -> Dict:
"""计算囚徒困境结果"""
if move1 == "C" and move2 == "C":
result = f"{self.players[0].name}：1年\n{self.players[1].name}：1年"
analysis = "两人都选择合作，结果相对较好。这是一个帕累托最优解。"
elif move1 == "D" and move2 == "D":
result = f"{self.players[0].name}：5年\n{self.players[1].name}：5年"
analysis = "两人都选择背叛，结果最差。这是纳什均衡。"
elif move1 == "C" and move2 == "D":
result = f"{self.players[0].name}：10年\n{self.players[1].name}：0年（释放）"
analysis = f"{self.players[1].name}利用了{self.players[0].name}的合作。"
else:
result = f"{self.players[0].name}：0年（释放）\n{self.players[1].name}：10年"
analysis = f"{self.players[0].name}利用了{self.players[1].name}的合作。"
return {
"result": result,
"analysis": analysis,
"player1_years": self._extract_years(result, 0),
"player2_years": self._extract_years(result, 1)
}教学型交互
1. 师生问答系统
@dataclass
class TutoringSystem:
"""师生问答系统"""
teacher: AICharacter
student: AICharacter
subject: str
topic: str
def __post_init__(self):
self.knowledge_state = {}
self.session_history = []
self.difficulty_level = "beginner"
def start_session(self) -> Dict:
"""开始教学会话"""
print(f"\n{'='*50}")
print(f"{self.subject}教学系统")
print(f"主题：{self.topic}")
print(f"教师：{self.teacher.name}")
print(f"学生：{self.student.name}")
print(f"{'='*50}\n")
# 阶段1：课程导入
print("\n【课程导入】\n")
introduction = self._course_introduction()
print(introduction)
# 阶段2：概念讲解
print("\n【概念讲解】\n")
concepts = self._explain_concepts()
# 阶段3：互动问答
print("\n【互动问答】\n")
qa_session = self._interactive_qa(concepts)
# 阶段4：练习测评
print("\n【练习测评】\n")
exercises = self._practice_exercises()
# 阶段5：总结反馈
print("\n【学习总结】\n")
summary = self._provide_summary(exercises)
return {
"subject": self.subject,
"topic": self.topic,
"concepts": concepts,
"qa_session": qa_session,
"exercises": exercises,
"summary": summary
}
def _course_introduction(self) -> str:
"""课程导入"""
prompt = f"""
你是{self.teacher.name}，一位经验丰富的{self.subject}教师。
请为{self.topic}这个主题设计一个引人入胜的课程导入：
1. 说明主题的重要性
2. 激发学习兴趣
3. 介绍课程目标
4. 语言生动有趣
5. 控制在200字以内
"""
return self._ask_character(self.teacher, prompt)
def _explain_concepts(self) -> List[Dict]:
"""讲解核心概念"""
prompt = f"""
你是{self.teacher.name}，正在讲解{self.topic}。
请列出这个主题的3-5个核心概念，并逐一详细讲解。
每个概念包括：
1. 概念名称
2. 简单定义
3. 实际例子
4. 常见误区
用清晰、易懂的语言讲解。
"""
response = self._ask_character(self.teacher, prompt)
# 解析概念
concepts = self._parse_concepts(response)
for concept in concepts:
print(f"\n{concept['name']}")
print(f"定义：{concept['definition']}")
print(f"例子：{concept['example']}")
print(f"注意：{concept['note']}")
return concepts
def _interactive_qa(self, concepts: List[Dict]) -> Dict:
"""互动问答"""
print(f"\n--- 互动问答环节 ---")
print(f"{self.student.name}可以随时提出问题\n")
# 学生提问
student_questions = self._generate_student_questions(concepts)
qa_history = []
for i, question in enumerate(student_questions[:3], 1):
print(f"\n【问题{i}】")
print(f"{self.student.name}: {question}\n")
# 教师回答
answer = self._teacher_answer(question, concepts)
print(f"{self.teacher.name}: {answer}\n")
# 检查学生是否理解
understanding = self._check_understanding(answer)
print(f"{self.student.name}的反应：{understanding}\n")
qa_history.append({
"question": question,
"answer": answer,
"understanding": understanding
})
return qa_history
def _generate_student_questions(self, concepts: List[Dict]) -> List[str]:
"""生成学生问题"""
questions = []
# 学生对每个概念提一个问题
for concept in concepts:
prompt = f"""
你是{self.student.name}，一个正在学习{self.subject}的学生。
刚才老师讲解了以下概念：
{concept['name']}：{concept['definition']}
作为一个学生，你会问什么问题来更好地理解这个概念？
请生成1-2个自然的问题。
"""
response = self._ask_character(self.student, prompt)
questions.append(response)
return questions
def _teacher_answer(self, question: str,
concepts: List[Dict]) -> str:
"""教师回答问题"""
prompt = f"""
你是{self.teacher.name}，一位善于教学的老师。
学生问题：{question}
相关概念：
{self._format_concepts(concepts)}
请回答这个问题：
1. 直接回答问题
2. 用简单易懂的语言
3. 提供具体例子
4. 激发进一步思考
"""
return self._ask_character(self.teacher, prompt)
def _practice_exercises(self) -> Dict:
"""练习测评"""
prompt = f"""
你是{self.teacher.name}，请为{self.topic}设计练习题。
要求：
1. 设计3道难度递进的题目
2. 包含填空题、选择题、简答题
3. 题目要覆盖核心概念
4. 同时提供答案和解析
"""
exercises = self._ask_character(self.teacher, prompt)
print(exercises)
# 学生答题
student_answers = self._student_answer_exercises(exercises)
# 评分
grading = self._grade_exercises(exercises, student_answers)
return {
"exercises": exercises,
"student_answers": student_answers,
"grading": grading
}
def _student_answer_exercises(self, exercises: str) -> Dict:
"""学生答题"""
prompt = f"""
你是{self.student.name}，请回答以下练习题：
{exercises}
请按照题目顺序给出你的答案。
"""
return {"answers": self._ask_character(self.student, prompt)}
def _grade_exercises(self, exercises: str,
answers: Dict) -> Dict:
"""评分"""
prompt = f"""
你是{self.teacher.name}，请批改学生的答案。
练习题：
{exercises}
学生答案：
{answers['answers']}
请给出：
1. 每题的得分和满分
2. 总分
3. 评语和改进建议
"""
grading = self._ask_character(self.teacher, prompt)
print(f"\n{grading}")
return {"grading": grading}游戏化交互
1. RPG冒险游戏
@dataclass
class RPGGame:
"""RPG冒险游戏"""
player: AICharacter
narrator: AICharacter
game_world: Dict
def __init__(self, player: AICharacter, narrator: AICharacter):
self.player = player
self.narrator = narrator
self.game_state = {
"location": "start",
"inventory": [],
"stats": {
"health": 100,
"mana": 100,
"experience": 0,
"level": 1
},
"quests": [],
"history": []
}
def start_game(self) -> Dict:
"""开始游戏"""
print(f"\n{'='*50}")
print("冒险游戏")
print(f"玩家：{self.player.name}")
print(f"{'='*50}\n")
# 开场介绍
intro = self._narrate_introduction()
print(intro)
# 游戏主循环
while True:
# 玩家决策
decision = self._player_decision()
print(f"\n{self.player.name}: {decision}")
# 处理行动
result = self._process_action(decision)
print(f"\n{result['narration']}")
# 更新状态
self.game_state.update(result["state_changes"])
# 检查游戏结束
if result.get("game_over"):
return self._game_over_summary()
# 休息一下
time.sleep(1)
def _narrate_introduction(self) -> str:
"""开场介绍"""
prompt = f"""
你是游戏讲述者。请为玩家创造一个引人入胜的开场场景。
玩家：{self.player.name}，{self.player.background}
请描述：
1. 玩家醒来的场景
2. 周围的环境
3. 第一个可探索的方向
4. 悬念和神秘感
用生动的语言描述，控制在200字以内。
"""
return self._ask_character(self.narrator, prompt)
def _player_decision(self) -> str:
"""玩家决策"""
prompt = f"""
你是{self.player.name}，正在冒险游戏中。
当前状态：
- 位置：{self.game_state['location']}
- 生命值：{self.game_state['stats']['health']}
- 法力值：{self.game_state['stats']['mana']}
- 物品：{', '.join(self.game_state['inventory']) or '无'}
之前的行动：
{'; '.join(self.game_state['history'][-5:])}
根据当前情况，你决定做什么？
请描述你的行动（移动、战斗、交互、探索等）。
"""
return self._ask_character(self.player, prompt)
def _process_action(self, action: str) -> Dict:
"""处理玩家行动"""
prompt = f"""
你是游戏GM（游戏主持人）。处理玩家的行动。
玩家行动：{action}
当前游戏状态：
{self._format_game_state()}
请判断玩家的行动：
1. 行动是否有效
2. 行动的结果
3. 是否触发事件
4. 状态变化（生命值、物品等）
5. 下一个场景描述
6. 游戏是否结束
用JSON格式返回结果：
{{
"valid": true/false,
"result": "行动结果描述",
"event": "触发的事件",
"state_changes": {{}},
"narration": "场景描述",
"game_over": true/false
}}
"""
response = self._ask_character(self.narrator, prompt)
return self._parse_action_result(response)2. 密室逃脱
@dataclass
class EscapeRoom:
"""密室逃脱游戏"""
players: List[AICharacter]
rooms: List[Dict]
time_limit: int = 30 # 分钟
def __post_init__(self):
self.game_state = {
"current_room": 0,
"collected_items": [],
"solved_puzzles": [],
"time_elapsed": 0
}
def play(self) -> Dict:
"""开始密室逃脱"""
print(f"\n{'='*50}")
print("密室逃脱挑战")
print(f"玩家：{', '.join(p.name for p in self.players)}")
print(f"时间限制：{self.time_limit}分钟")
print(f"{'='*50}\n")
# 游戏开始
start_time = time.time()
while not self._check_win():
# 检查时间
elapsed = int((time.time() - start_time) / 60)
if elapsed >= self.time_limit:
return self._game_over("timeout")
# 描述当前房间
room_description = self._describe_room()
print(f"\n【当前房间】\n{room_description}")
# 玩家讨论
discussion = self._player_discussion()
print(f"\n【玩家讨论】\n{discussion}")
# 玩家行动
action = self._collective_action()
print(f"\n【玩家行动】{action}")
# 处理行动
result = self._process_action(action)
print(f"\n{result['description']}")
# 更新状态
self.game_state.update(result["state_changes"])
return self._game_over("success")
def _describe_room(self) -> str:
"""描述当前房间"""
current_room = self.rooms[self.game_state["current_room"]]
prompt = f"""
你是密室逃脱游戏的讲述者。描述当前房间：
房间信息：
- 名称：{current_room['name']}
- 描述：{current_room['description']}
- 线索：{', '.join(current_room['clues'])}
- 谜题：{current_room.get('puzzle', '无')}
- 机关：{', '.join(current_room.get('mechanisms', []))}
已收集物品：{', '.join(self.game_state['collected_items']) or '无'}
请用描述性的语言讲述房间环境，突出可互动的元素。
"""
return self.llm_generate(prompt)
def _player_discussion(self) -> str:
"""玩家讨论"""
players_text = "\n".join([
f"- {p.name}: {p.role}，{p.specialty}"
for p in self.players
])
prompt = f"""
模拟密室逃脱游戏中玩家之间的讨论。
玩家：
{players_text}
请模拟玩家的讨论过程：
1. 每个玩家提出观察或想法
2. 互相质疑或补充
3. 尝试找到线索之间的联系
4. 讨论可能的解谜思路
用对话形式呈现讨论过程。
"""
return self.llm_generate(prompt)
def _collective_action(self) -> str:
"""集体行动"""
prompt = f"""
基于以上讨论，玩家决定采取什么行动？
行动可以是：
- 检查某个物品
- 尝试解开谜题
- 操作机关
- 移动到其他区域
- 使用物品
请描述玩家的集体行动。
"""
return self.llm_generate(prompt)实战项目
1. 智能客服系统
class IntelligentCustomerService:
"""智能客服系统"""
def __init__(self):
# 定义角色
self.intent_agent = IntentRecognitionAgent()
self.faq_agent = FAQAgent()
self.order_agent = OrderAgent()
self.empathy_agent = EmpathyAgent()
self.human_agent = HumanAgent()
# 状态管理
self.session_states = {}
def handle_query(self, user_id: str, query: str) -> Dict:
"""处理用户查询"""
# 获取会话状态
state = self._get_state(user_id)
# 情感分析
emotion = self.empathy_agent.analyze_emotion(query)
state["emotion"] = emotion
# 意图识别
intent = self.intent_agent.recognize(query, state["context"])
state["intent"] = intent
# 根据意图路由
if intent == "faq":
response = self.faq_agent.handle(query, state)
elif intent == "order":
response = self.order_agent.handle(query, state)
elif intent == "complaint":
response = self._handle_complaint(query, state)
else:
response = self._unknown_intent(query)
# 添加情感回应
if emotion in ["angry", "frustrated"]:
empathy_response = self.empathy_agent.generate_response(emotion)
response = f"{empathy_response}\n\n{response}"
# 保存状态
self._save_state(user_id, state)
return response
def _handle_complaint(self, query: str, state: Dict) -> str:
"""处理投诉"""
# 记录投诉
complaint_id = self._record_complaint(query, state)
# 生成回应
response = f"""
非常抱歉给您带来不便。您的投诉（编号：{complaint_id}）已记录。
我们会尽快处理，并在24小时内给您反馈。
您还有其他需要帮助的吗？
"""
# 检查是否需要转人工
if self._needs_human_escalation(query, state):
return self._escalate_to_human(complaint_id)
return response2. 智能写作助手
class WritingAssistant:
"""智能写作助手"""
def __init__(self):
self.planner = WritingPlannerAgent()
self.outliner = OutlineGeneratorAgent()
self.writer = ContentWriterAgent()
self.editor = EditorAgent()
self.critic = CriticAgent()
def assist_writing(self, topic: str, style: str) -> Dict:
"""协助写作"""
print(f"\n开始写作主题：{topic}")
print(f"写作风格：{style}\n")
# 1. 写作规划
print("【写作规划】")
plan = self.planner.create_plan(topic, style)
print(plan)
# 2. 生成大纲
print("\n【生成大纲】")
outline = self.outliner.generate_outline(plan)
print(outline)
# 3. 迭代写作
print("\n【内容创作】")
content = ""
for section in outline["["sections"]]:
section_content = self.writer.write_section(section, style)
content += section_content + "\n\n"
# 4. 编辑优化
print("\n【编辑优化】")
edited_content = self.editor.edit(content, style)
# 5. 评审
print("\n【内容评审】")
review = self.critic.review(edited_content, plan)
return {
"topic": topic,
"style": style,
"outline": outline,
"content": edited_content,
"review": review
}面试高频问法
Q1: 如何设计复杂AI交互系统？
【标准回答】
设计要点：
1. 角色设计
- 定义清晰的角色
- 设置性格特征
- 确保角色一致性
2. 状态管理
- 对话状态跟踪
- 上下文维护
- 记忆持久化
3. 流程控制
- 状态机设计
- 分支处理
- 错误恢复
4. 反馈机制
- 多维反馈
- 实时评估
- 动态调整Q2: 如何确保角色一致性？
【标准回答】
一致性保证：
1. 角色定义
- 明确的角色设定
- 详细的背景故事
- 稳定的性格特征
2. 提示工程
- 系统提示固定
- 角色信息注入
- 行为约束明确
3. 记忆机制
- 长期记忆
- 对话历史
- 角色记忆更新
4. 验证机制
- 输出检查
- 偏离检测
- 自动修正Q3: 如何处理复杂交互分支？
【标准回答】
分支处理：
1. 状态机
- 定义所有状态
- 明确转换规则
- 可视化流程
2. 事件驱动
- 事件定义
- 事件路由
- 异步处理
3. 决策树
- 条件分支
- 概率决策
- 优先级处理
4. 恢复机制
- 状态保存
- 回退功能
- 重置选项记忆要点
【复杂交互特征】
多目标协作
多AI角色
复杂状态机
非线性流程
多维反馈
长短期记忆
【交互类型】
协作型：分工合作、共同决策
竞争型：对立博弈、策略选择
教学型：师生互动、知识传递
游戏化：游戏规则、成就感
模拟型：场景推演、行为预测
【设计原则】
可用性：明确引导、合理流程、错误容忍
沉浸感：角色一致、自然对话、场景真实
可扩展：模块化、数据驱动、性能优化
【核心组件】
角色管理：定义、行为、记忆
状态管理：跟踪、转换、恢复
流程控制：状态机、事件、决策
反馈系统：评估、调整、优化文档版本: 1.0
