admin/MuMuAINovel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update:1.更新AI生成角色/组织实现自动建立关系 2.新增AI续写大纲智能引入角色功能

Browse Source
This commit is contained in:
xiamuceer
2025-12-11 12:43:28 +08:00
parent 9fcc06055c
commit 02bd2a2529
17 changed files with 2356 additions and 430 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/app/services/auto_character_service.py
+509
View File
@@ -0,0 +1,509 @@
"""自动角色引入服务 - 在续写大纲时根据剧情推进自动引入新角色"""
from typing import List, Dict, Any, Optional
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select
import json
from app.models.character import Character
from app.models.relationship import CharacterRelationship, Organization, OrganizationMember, RelationshipType
from app.models.project import Project
from app.services.ai_service import AIService
from app.services.prompt_service import PromptService
from app.logger import get_logger
logger = get_logger(__name__)
class AutoCharacterService:
"""自动角色引入服务"""
def __init__(self, ai_service: AIService):
self.ai_service = ai_service
async def analyze_and_create_characters(
self,
project_id: str,
outline_content: str,
existing_characters: List[Character],
db: AsyncSession,
user_id: str = None,
enable_mcp: bool = True,
all_chapters_brief: str = "",
start_chapter: int = 1,
chapter_count: int = 3,
plot_stage: str = "发展",
story_direction: str = "继续推进主线剧情",
preview_only: bool = False
) -> Dict[str, Any]:
"""
预测性分析并创建需要的新角色（方案A：先角色后大纲）
Args:
project_id: 项目ID
outline_content: 当前批次大纲内容（用于向后兼容，实际不使用）
existing_characters: 现有角色列表
db: 数据库会话
user_id: 用户ID(用于MCP和自定义提示词)
enable_mcp: 是否启用MCP增强
all_chapters_brief: 已有章节概览
start_chapter: 起始章节号
chapter_count: 续写章节数
plot_stage: 剧情阶段
story_direction: 故事发展方向
preview_only: 仅预测不创建（用于角色确认机制）
Returns:
{
"new_characters": [角色对象列表], # preview_only=True时为空
"relationships_created": [关系对象列表], # preview_only=True时为空
"character_count": 新增角色数量,
"analysis_result": AI分析结果,
"predicted_characters": [预测的角色数据] # 仅preview_only=True时返回
"needs_new_characters": bool,
"reason": str
}
"""
logger.info(f"🎭 【方案A】预测性分析：检测是否需要引入新角色...")
logger.info(f" - 项目ID: {project_id}")
logger.info(f" - 续写计划: 第{start_chapter}章起，共{chapter_count}章")
logger.info(f" - 剧情阶段: {plot_stage}")
logger.info(f" - 发展方向: {story_direction}")
logger.info(f" - 现有角色数: {len(existing_characters)}")
# 1. 获取项目信息
project_result = await db.execute(
select(Project).where(Project.id == project_id)
)
project = project_result.scalar_one_or_none()
if not project:
raise ValueError("项目不存在")
# 2. 构建现有角色信息摘要
existing_chars_summary = self._build_character_summary(existing_characters)
# 3. AI预测性分析是否需要新角色
analysis_result = await self._analyze_character_needs(
project=project,
outline_content=outline_content, # 保留参数向后兼容
existing_chars_summary=existing_chars_summary,
db=db,
user_id=user_id,
enable_mcp=enable_mcp,
all_chapters_brief=all_chapters_brief,
start_chapter=start_chapter,
chapter_count=chapter_count,
plot_stage=plot_stage,
story_direction=story_direction
)
# 4. 判断是否需要创建角色
if not analysis_result or not analysis_result.get("needs_new_characters"):
logger.info("✅ AI判断：当前剧情不需要引入新角色")
return {
"new_characters": [],
"relationships_created": [],
"character_count": 0,
"analysis_result": analysis_result,
"predicted_characters": [],
"needs_new_characters": False,
"reason": analysis_result.get("reason", "当前剧情不需要新角色")
}
# 5. 如果是预览模式，仅返回预测结果，不创建角色
if preview_only:
character_specs = analysis_result.get("character_specifications", [])
logger.info(f"🔮 预览模式：预测到 {len(character_specs)} 个角色，不创建数据库记录")
return {
"new_characters": [],
"relationships_created": [],
"character_count": 0,
"analysis_result": analysis_result,
"predicted_characters": character_specs,
"needs_new_characters": True,
"reason": analysis_result.get("reason", "预测需要新角色")
}
# 6. 批量生成新角色（非预览模式）
new_characters = []
relationships_created = []
character_specs = analysis_result.get("character_specifications", [])
logger.info(f"🎯 AI建议引入 {len(character_specs)} 个新角色")
for idx, spec in enumerate(character_specs):
try:
spec_name = spec.get('name', spec.get('role_description', '未命名'))
logger.info(f" [{idx+1}/{len(character_specs)}] 生成角色规格: {spec_name}")
logger.debug(f" 角色规格内容: {json.dumps(spec, ensure_ascii=False)}")
# 生成角色详细信息
character_data = await self._generate_character_details(
spec=spec,
project=project,
existing_characters=existing_characters + new_characters, # 包含新创建的
db=db,
user_id=user_id,
enable_mcp=enable_mcp
)
logger.debug(f" AI生成的角色数据: {json.dumps(character_data, ensure_ascii=False)[:200]}")
# 创建角色记录
character = await self._create_character_record(
project_id=project_id,
character_data=character_data,
db=db
)
new_characters.append(character)
logger.info(f" ✅ 创建新角色: {character.name} ({character.role_type}), ID: {character.id}")
# 建立关系（兼容两种字段名）
relationships_data = character_data.get("relationships") or character_data.get("relationships_array", [])
logger.info(f" 🔍 检查关系数据:")
logger.info(f" - relationships字段: {character_data.get('relationships')}")
logger.info(f" - relationships_array字段: {character_data.get('relationships_array')}")
logger.info(f" - 最终使用的数据: {relationships_data}")
logger.info(f" - 关系数量: {len(relationships_data) if relationships_data else 0}")
if relationships_data:
logger.info(f" 🔗 开始创建 {len(relationships_data)} 条关系...")
for idx, rel in enumerate(relationships_data):
logger.info(f" [{idx+1}] {rel.get('target_character_name')} - {rel.get('relationship_type')}")
else:
logger.warning(f" ⚠️ AI返回的角色数据中没有关系信息！")
logger.warning(f" 完整的character_data keys: {list(character_data.keys())}")
rels = await self._create_relationships(
new_character=character,
relationship_specs=relationships_data,
existing_characters=existing_characters + new_characters,
project_id=project_id,
db=db
)
relationships_created.extend(rels)
logger.info(f" ✅ 实际创建了 {len(rels)} 条关系记录")
except Exception as e:
logger.error(f" ❌ 创建角色失败: {e}", exc_info=True)
continue
# 7. 提交事务（注意：这里只flush，让调用方commit）
await db.flush()
logger.info(f"🎉 自动角色引入完成: 新增{len(new_characters)}个角色, {len(relationships_created)}条关系")
return {
"new_characters": new_characters,
"relationships_created": relationships_created,
"character_count": len(new_characters),
"analysis_result": analysis_result
}
def _build_character_summary(self, characters: List[Character]) -> str:
"""构建现有角色摘要"""
if not characters:
return "暂无角色"
summary = []
for char in characters:
char_type = "组织" if char.is_organization else "角色"
role_desc = char.role_type or "未知"
personality = (char.personality or "")[:50]
summary.append(f"- {char.name} ({char_type}, {role_desc}): {personality}")
return "\n".join(summary[:20]) # 最多显示20个
async def _analyze_character_needs(
self,
project: Project,
outline_content: str,
existing_chars_summary: str,
db: AsyncSession,
user_id: str,
enable_mcp: bool,
all_chapters_brief: str = "",
start_chapter: int = 1,
chapter_count: int = 3,
plot_stage: str = "发展",
story_direction: str = "继续推进主线剧情"
) -> Dict[str, Any]:
"""AI预测性分析是否需要新角色（方案A）"""
# 构建分析提示词
template = await PromptService.get_template(
"AUTO_CHARACTER_ANALYSIS",
user_id,
db
)
# 使用新的预测性分析参数
prompt = PromptService.format_prompt(
template,
title=project.title,
theme=project.theme or "未设定",
genre=project.genre or "未设定",
time_period=project.world_time_period or "未设定",
location=project.world_location or "未设定",
atmosphere=project.world_atmosphere or "未设定",
existing_characters=existing_chars_summary,
all_chapters_brief=all_chapters_brief,
start_chapter=start_chapter,
chapter_count=chapter_count,
plot_stage=plot_stage,
story_direction=story_direction
)
try:
# 调用AI分析
if enable_mcp and user_id:
result = await self.ai_service.generate_text_with_mcp(
prompt=prompt,
user_id=user_id,
db_session=db,
enable_mcp=True,
max_tool_rounds=1
)
content = result.get("content", "")
else:
result = await self.ai_service.generate_text(prompt=prompt)
content = result.get("content", "") if isinstance(result, dict) else result
# 清理并解析JSON
cleaned = content.strip()
if cleaned.startswith("```json"):
cleaned = cleaned[7:]
if cleaned.startswith("```"):
cleaned = cleaned[3:]
if cleaned.endswith("```"):
cleaned = cleaned[:-3]
cleaned = cleaned.strip()
analysis = json.loads(cleaned)
logger.info(f" ✅ AI分析完成: needs_new_characters={analysis.get('needs_new_characters')}")
return analysis
except json.JSONDecodeError as e:
logger.error(f" ❌ 角色需求分析JSON解析失败: {e}")
logger.error(f" 响应内容: {content[:500]}")
return {"needs_new_characters": False}
except Exception as e:
logger.error(f" ❌ 角色需求分析失败: {e}")
return {"needs_new_characters": False}
async def _generate_character_details(
self,
spec: Dict[str, Any],
project: Project,
existing_characters: List[Character],
db: AsyncSession,
user_id: str,
enable_mcp: bool
) -> Dict[str, Any]:
"""生成角色详细信息"""
# 构建角色生成提示词
template = await PromptService.get_template(
"AUTO_CHARACTER_GENERATION",
user_id,
db
)
existing_chars_summary = self._build_character_summary(existing_characters)
prompt = PromptService.format_prompt(
template,
title=project.title,
genre=project.genre or "未设定",
theme=project.theme or "未设定",
time_period=project.world_time_period or "未设定",
location=project.world_location or "未设定",
atmosphere=project.world_atmosphere or "未设定",
rules=project.world_rules or "未设定",
existing_characters=existing_chars_summary,
plot_context="根据剧情需要引入的新角色",
character_specification=json.dumps(spec, ensure_ascii=False, indent=2),
mcp_references="" # 暂时不使用MCP增强
)
# 调用AI生成
try:
if enable_mcp and user_id:
result = await self.ai_service.generate_text_with_mcp(
prompt=prompt,
user_id=user_id,
db_session=db,
enable_mcp=True,
max_tool_rounds=1
)
content = result.get("content", "")
else:
result = await self.ai_service.generate_text(prompt=prompt)
content = result.get("content", "") if isinstance(result, dict) else result
# 解析JSON
cleaned = content.strip()
if cleaned.startswith("```json"):
cleaned = cleaned[7:]
if cleaned.startswith("```"):
cleaned = cleaned[3:]
if cleaned.endswith("```"):
cleaned = cleaned[:-3]
character_data = json.loads(cleaned.strip())
char_name = character_data.get('name', '未知')
logger.info(f" ✅ 角色详情生成成功: {char_name}")
logger.debug(f" 角色数据字段: {list(character_data.keys())}")
# 确保关键字段存在
if 'name' not in character_data or not character_data['name']:
logger.warning(f" ⚠️ AI返回的角色数据缺少name字段，使用规格中的信息")
character_data['name'] = spec.get('name', f"新角色{spec.get('role_description', '')[:10]}")
return character_data
except Exception as e:
logger.error(f" ❌ 生成角色详情失败: {e}")
raise
async def _create_character_record(
self,
project_id: str,
character_data: Dict[str, Any],
db: AsyncSession
) -> Character:
"""创建角色数据库记录"""
is_organization = character_data.get("is_organization", False)
# 创建角色
character = Character(
project_id=project_id,
name=character_data.get("name", "未命名角色"),
age=str(character_data.get("age", "")),
gender=character_data.get("gender"),
is_organization=is_organization,
role_type=character_data.get("role_type", "supporting"),
personality=character_data.get("personality", ""),
background=character_data.get("background", ""),
appearance=character_data.get("appearance", ""),
relationships=character_data.get("relationships_text", ""),
organization_type=character_data.get("organization_type") if is_organization else None,
organization_purpose=character_data.get("organization_purpose") if is_organization else None,
traits=json.dumps(character_data.get("traits", []), ensure_ascii=False) if character_data.get("traits") else None
)
db.add(character)
await db.flush()
# 如果是组织，创建Organization记录
if is_organization:
org = Organization(
character_id=character.id,
project_id=project_id,
member_count=0,
power_level=character_data.get("power_level", 50),
location=character_data.get("location"),
motto=character_data.get("motto"),
color=character_data.get("color")
)
db.add(org)
await db.flush()
logger.info(f" ✅ 创建组织详情: {character.name}")
return character
async def _create_relationships(
self,
new_character: Character,
relationship_specs: List[Dict[str, Any]],
existing_characters: List[Character],
project_id: str,
db: AsyncSession
) -> List[CharacterRelationship]:
"""创建角色关系"""
if not relationship_specs:
return []
relationships = []
for rel_spec in relationship_specs:
try:
target_name = rel_spec.get("target_character_name")
if not target_name:
continue
# 查找目标角色
target_char = next(
(c for c in existing_characters if c.name == target_name),
None
)
if not target_char:
logger.warning(f" ⚠️ 目标角色不存在: {target_name}")
continue
# 检查关系是否已存在
existing_rel = await db.execute(
select(CharacterRelationship).where(
CharacterRelationship.project_id == project_id,
CharacterRelationship.character_from_id == new_character.id,
CharacterRelationship.character_to_id == target_char.id
)
)
if existing_rel.scalar_one_or_none():
logger.debug(f" ℹ️ 关系已存在: {new_character.name} -> {target_name}")
continue
# 创建关系
relationship = CharacterRelationship(
project_id=project_id,
character_from_id=new_character.id,
character_to_id=target_char.id,
relationship_name=rel_spec.get("relationship_type", "未知关系"),
intimacy_level=rel_spec.get("intimacy_level", 50),
description=rel_spec.get("description", ""),
status=rel_spec.get("status", "active"),
source="auto" # 标记为自动生成
)
# 尝试匹配预定义关系类型
rel_type_name = rel_spec.get("relationship_type")
if rel_type_name:
rel_type_result = await db.execute(
select(RelationshipType).where(
RelationshipType.name == rel_type_name
)
)
rel_type = rel_type_result.scalar_one_or_none()
if rel_type:
relationship.relationship_type_id = rel_type.id
db.add(relationship)
relationships.append(relationship)
logger.info(
f" ✅ 创建关系: {new_character.name} -> {target_name} "
f"({rel_spec.get('relationship_type', '未知')})"
)
except Exception as e:
logger.warning(f" ❌ 创建关系失败: {e}")
continue
return relationships
# 全局实例缓存
_auto_character_service_instance: Optional[AutoCharacterService] = None
def get_auto_character_service(ai_service: AIService) -> AutoCharacterService:
"""获取自动角色服务实例（单例模式）"""
global _auto_character_service_instance
if _auto_character_service_instance is None:
_auto_character_service_instance = AutoCharacterService(ai_service)
return _auto_character_service_instance
backend/app/services/prompt_service.py
+201
View File
@@ -1437,6 +1437,193 @@ class PromptService:
3. 每个plot_summary必须是200-300字的详细描述
4. 所有内容描述中严禁使用任何特殊符号"""
# 自动角色引入 - 预测性分析提示词（方案A）
AUTO_CHARACTER_ANALYSIS = """你是专业的小说角色设计顾问。请根据即将续写的剧情方向，预测是否需要引入新角色。
【项目信息】
- 书名：{title}
- 类型：{genre}
- 主题：{theme}
【世界观】
- 时间背景：{time_period}
- 地理位置：{location}
- 氛围基调：{atmosphere}
【已有角色】
{existing_characters}
【已有章节概览】
{all_chapters_brief}
【续写计划】
- 起始章节：第{start_chapter}章
- 续写数量：{chapter_count}章
- 剧情阶段：{plot_stage}
- 发展方向：{story_direction}
【预测性分析任务】
请预测在接下来的{chapter_count}章中，根据剧情发展方向和阶段，是否需要引入新角色。
**分析要点：**
1. **剧情需求预测**：根据发展方向，哪些场景、冲突需要新角色参与
2. **角色充分性**：现有角色是否足以支撑即将发生的剧情
3. **引入时机**：新角色应该在哪个章节登场最合适
4. **重要性判断**：新角色对后续剧情的影响程度
**预测依据：**
- 剧情阶段的典型角色需求（如：高潮阶段可能需要强力对手）
- 故事发展方向的逻辑需要（如：进入新地点需要当地角色）
- 冲突升级的角色需求（如：更强的反派、意外的盟友）
- 世界观扩展的需要（如：新组织、新势力的代表）
**如果需要新角色，请详细说明：**
- 角色定位和作用
- 建议的角色类型和重要性
- 预计登场时机
- 与现有角色的潜在关系
**输出格式（纯JSON）：**
{{
"needs_new_characters": true,
"reason": "预测分析原因（150-200字），说明为什么即将的剧情需要新角色",
"character_count": 2,
"character_specifications": [
{{
"name": "建议的角色名字（可选，如果有明确想法）",
"role_description": "角色在剧情中的定位和作用（100-150字）",
"suggested_role_type": "supporting/antagonist/protagonist",
"importance": "high/medium/low",
"appearance_chapter": {start_chapter},
"key_abilities": ["能力1", "能力2"],
"plot_function": "在剧情中的具体功能（如：作为主要对手、提供关键信息等）",
"relationship_suggestions": [
{{
"target_character": "现有角色名",
"relationship_type": "建议的关系类型",
"reason": "为什么建立这种关系"
}}
]
}}
]
}}
或者如果不需要新角色：
{{
"needs_new_characters": false,
"reason": "现有角色足以支撑即将的剧情发展，说明理由"
}}
**重要提示：**
- 这是预测性分析，不是基于已生成内容的事后分析
- 要考虑剧情的自然发展和节奏
- 不要为了引入角色而引入，确保必要性
- 优先考虑角色的长期作用，而非一次性功能
只返回纯JSON，不要有markdown标记或其他文字。"""
# 自动角色引入 - 生成提示词
AUTO_CHARACTER_GENERATION = """你是专业的角色设定师。请根据以下信息，为小说生成新角色的完整设定。
【项目信息】
- 书名：{title}
- 类型：{genre}
- 主题：{theme}
【世界观】
- 时间背景：{time_period}
- 地理位置：{location}
- 氛围基调：{atmosphere}
- 世界规则：{rules}
【已有角色】
{existing_characters}
【剧情上下文】
{plot_context}
【角色规格要求】
{character_specification}
【MCP工具参考】
{mcp_references}
【生成要求】
1. 角色必须符合剧情需求和世界观设定
2. **必须分析新角色与已有角色的关系**，至少建立1-3个有意义的关系
3. 性格、背景要有深度和独特性
4. 外貌描写要具体生动
5. 特长和能力要符合角色定位
**关系建立指导（非常重要）：**
- 仔细审视【已有角色】列表，思考新角色与哪些现有角色有联系
- 根据剧情需求，建立合理的角色关系（如：主角的新朋友、反派的手下、某角色的亲属等）
- 每个关系都要有明确的类型、亲密度和描述
- 关系应该服务于剧情发展，推动故事前进
- 如果新角色是组织成员，记得填写organization_memberships
**重要格式要求：**
1. 只返回纯JSON格式，不要包含任何markdown标记或其他说明文字
2. JSON字符串值中严禁使用特殊符号（引号、方括号、书名号等）
3. 所有专有名词直接书写，不使用任何符号包裹
请严格按照以下JSON格式返回：
{{
"name": "角色姓名",
"age": 25,
"gender": "男/女/其他",
"role_type": "supporting",
"personality": "性格特点的详细描述（100-200字）",
"background": "背景故事的详细描述（100-200字）",
"appearance": "外貌描述（50-100字）",
"traits": ["特长1", "特长2", "特长3"],
"relationships_text": "用自然语言描述该角色与其他角色的关系网络",
"relationships": [
{{
"target_character_name": "已存在的角色名称",
"relationship_type": "关系类型（如：朋友、师父、敌人、父亲等）",
"intimacy_level": 75,
"description": "关系的具体描述，说明他们如何认识、关系如何发展",
"status": "active"
}}
],
"organization_memberships": [
{{
"organization_name": "已存在的组织名称",
"position": "职位",
"rank": 5,
"loyalty": 80
}}
]
}}
**关系类型参考（从中选择或自定义）：**
- 家族关系：父亲、母亲、兄弟、姐妹、子女、配偶、恋人、亲戚
- 社交关系：师父、徒弟、朋友、挚友、同学、同事、邻居、知己、酒友
- 职业关系：上司、下属、合作伙伴、客户、雇主、员工
- 敌对关系：敌人、仇人、竞争对手、宿敌、死敌
**重要说明：**
1. **relationships数组必填**：至少要有1-3个与已有角色的关系（除非确实没有合理的关联）
2. **target_character_name必须精确匹配**：只能引用【已有角色】列表中的角色名称
3. organization_memberships只能引用已存在的组织名称
4. intimacy_level是-100到100的整数：
- 80-100：至亲、挚友、深爱
- 50-79：亲密、友好
- 0-49：一般、普通
- -1到-49：不和、敌视
- -50到-100：仇恨、死敌
5. loyalty是0-100的整数（仅用于组织成员）
6. status默认为"active"，表示当前关系状态
**关系建立示例：**
- 如果新角色是主角的新队友，应该与主角建立"队友"或"朋友"关系
- 如果新角色是反派的手下，应该与反派建立"上司-下属"关系
- 如果新角色与某角色有血缘，应该建立家族关系
只返回纯JSON对象，不要有```json```这样的标记。"""
@staticmethod
def format_prompt(template: str, **kwargs) -> str:
"""
@@ -2306,6 +2493,20 @@ class PromptService:
"category": "MCP增强",
"description": "使用MCP工具搜索资料辅助角色设计",
"parameters": ["title", "genre", "theme", "time_period", "location"]
},
"AUTO_CHARACTER_ANALYSIS": {
"name": "自动角色分析",
"category": "自动角色引入",
"description": "分析新生成的大纲，判断是否需要引入新角色",
"parameters": ["title", "genre", "theme", "time_period", "location", "atmosphere",
"existing_characters", "new_outlines", "start_chapter", "end_chapter"]
},
"AUTO_CHARACTER_GENERATION": {
"name": "自动角色生成",
"category": "自动角色引入",
"description": "根据剧情需求自动生成新角色的完整设定",
"parameters": ["title", "genre", "theme", "time_period", "location", "atmosphere", "rules",
"existing_characters", "plot_context", "character_specification", "mcp_references"]
}
}