""" MACP 业务服务层模块。 为平台各功能模块提供业务逻辑实现，基于内存假数据模拟完整业务流程。 包含以下服务： - TemplateService: 文档模板管理服务 - GjbValidatorService: GJB合规验证服务 - DocumentService: 文档管理服务 - SkillService: Skills编排服务 - MemoryService: 智能体记忆管理服务 - KnowledgeBaseService: 知识库交互服务 - ModelService: 大模型接入管理服务 - MultimodalService: 多模态处理服务 - SandboxService: 安全沙箱执行服务 - McpToolService: MCP工具管理服务 """ from __future__ import annotations import uuid from datetime import datetime from typing import Any, Optional from app.models import ( Document, DocumentStatus, FileType, GjbRule, GjbStandard, KnowledgeChunk, KnowledgeLevel, McpTool, MemoryEntry, MemoryType, ModelProfile, ModelStatus, MultimodalResult, Skill, Template, TemplateType, ValidationReport, Workflow, ) # ============================================================================= # 假数据初始化 # ============================================================================= def _init_mock_templates() -> dict[str, Template]: """初始化假数据模板库""" templates = {} t1 = Template( id="TPL-001", name="GJB438C 软件需求规格说明书模板", template_type=TemplateType.SRS, gjb_standard=GjbStandard.GJB438C, version="2.0", content_structure={ "sections": [ {"id": "1", "title": "范围", "required": True}, {"id": "2", "title": "引用文档", "required": True}, {"id": "3", "title": "需求", "required": True}, {"id": "3.1", "title": "功能需求", "required": True}, {"id": "3.2", "title": "接口需求", "required": True}, {"id": "4", "title": "合格性需求", "required": True}, {"id": "5", "title": "需求可追踪性", "required": False}, ] }, author="系统管理员", ) t2 = Template( id="TPL-002", name="GJB438C 软件设计说明书模板", template_type=TemplateType.SDD, gjb_standard=GjbStandard.GJB438C, version="1.5", content_structure={ "sections": [ {"id": "1", "title": "范围", "required": True}, {"id": "2", "title": "引用文档", "required": True}, {"id": "3", "title": "软件体系结构设计", "required": True}, {"id": "4", "title": "软件详细设计", "required": True}, ] }, author="系统管理员", ) templates[t1.id] = t1 templates[t2.id] = t2 return templates def _init_mock_rules() -> dict[str, GjbRule]: """初始化假数据GJB规则库""" rules = {} rule_data = [ ("R-001", "1", "文档必须包含'范围'章节，说明软件用途和背景", True, [TemplateType.SRS, TemplateType.SDD], "建议在文档开头添加'范围'章节"), ("R-002", "2", "文档必须包含'引用文档'章节，列出所有参考文献", True, [TemplateType.SRS, TemplateType.SDD], "建议添加'引用文档'章节并列出参考文献"), ("R-003", "3", "需求规格说明书必须包含功能需求和接口需求", True, [TemplateType.SRS], "请补充功能需求和接口需求章节"), ("R-004", "3.1", "每项功能需求必须有唯一标识符", True, [TemplateType.SRS], "请为功能需求添加唯一标识符"), ("R-005", "3.2", "接口需求应明确输入输出数据格式", True, [TemplateType.SRS], "请补充接口的数据格式说明"), ("R-006", "4", "文档应包含合格性需求章节", False, [TemplateType.SRS], "建议添加合格性需求章节"), ("R-007", "5", "需求应具备可追踪性", False, [TemplateType.SRS], "建议添加需求追踪矩阵"), ] for rid, sec, req, man, types, sug in rule_data: rules[rid] = GjbRule( id=rid, section=sec, requirement=req, mandatory=man, applicable_types=types, suggestion=sug, ) return rules def _init_mock_documents() -> dict[str, Document]: """初始化假数据文档库""" docs = {} d1 = Document( id="DOC-001", title="某型雷达系统软件需求规格说明书", template_id="TPL-001", current_version="1.0", content="# 1. 范围\n\n本文档描述了某型雷达系统的软件需求。\n\n# 2. 引用文档\n\n- GJB438C-2021\n\n# 3. 需求\n\n## 3.1 功能需求\n\n- FR-001: 目标探测功能\n- FR-002: 目标跟踪功能\n\n## 3.2 接口需求\n\n...", edit_history=[ {"version": "1.0", "editor": "张三", "timestamp": "2024-01-15T10:00:00Z"}, ], status=DocumentStatus.DRAFT, ) d2 = Document( id="DOC-002", title="某型通信系统软件设计说明书", template_id="TPL-002", current_version="1.0", content="# 1. 范围\n\n本文档描述了某型通信系统的软件设计。\n\n# 2. 引用文档\n\n- GJB438C-2021\n\n# 3. 软件体系结构设计\n\n采用分层架构设计。", status=DocumentStatus.SUBMITTED, ) docs[d1.id] = d1 docs[d2.id] = d2 return docs def _init_mock_skills() -> dict[str, Skill]: """初始化假数据Skills库""" skills = {} s1 = Skill( id="SK-001", name="文档合规审查", prompt_template="请根据GJB标准对以下文档进行合规性审查：{document_content}", associated_tools=["gjb_validator", "llm_analyzer"], input_definition={"document_id": "string"}, output_definition={"report": "object"}, orchestration_order=1, ) s2 = Skill( id="SK-002", name="文档智能生成", prompt_template="请根据模板{template_id}生成{title}文档初稿", associated_tools=["template_loader", "llm_generator"], input_definition={"template_id": "string", "title": "string"}, output_definition={"document": "object"}, orchestration_order=2, ) skills[s1.id] = s1 skills[s2.id] = s2 return skills def _init_mock_memories() -> dict[str, MemoryEntry]: """初始化假数据记忆库""" memories = {} m1 = MemoryEntry( id="MEM-001", session_id="SESS-001", summary="用户询问GJB438C标准要求", original_dialogue="用户：GJB438C标准对需求文档有什么要求？\n助手：GJB438C标准要求需求文档包含范围、引用文档、需求等章节。", memory_type=MemoryType.LONG_TERM, ) m2 = MemoryEntry( id="MEM-002", session_id="SESS-001", summary="用户创建了新文档模板", original_dialogue="用户：请创建一个新的SRS模板。\n助手：已创建完成，模板ID为TPL-003。", memory_type=MemoryType.SHORT_TERM, ) memories[m1.id] = m1 memories[m2.id] = m2 return memories def _init_mock_knowledge() -> dict[str, KnowledgeChunk]: """初始化假数据知识库""" chunks = {} c1 = KnowledgeChunk( id="KC-001", source_document="GJB438C-2021 军用软件文档编制要求", level=KnowledgeLevel.DOCUMENT, content="本标准规定了军用软件文档的编制要求，适用于军用软件的研制全过程。", metadata_tags=["GJB438C", "标准", "文档编制"], ) c2 = KnowledgeChunk( id="KC-002", source_document="GJB438C-2021 军用软件文档编制要求", level=KnowledgeLevel.CHAPTER, content="第4章 软件需求规格说明书编制要求：应包括范围、引用文档、需求等章节。", metadata_tags=["GJB438C", "SRS", "需求规格说明书"], ) c3 = KnowledgeChunk( id="KC-003", source_document="某型雷达系统软件需求规格说明书", level=KnowledgeLevel.PARAGRAPH, content="功能需求FR-001：系统应具备对空中目标的探测能力，探测距离不小于300km。", metadata_tags=["雷达系统", "功能需求", "FR-001"], ) chunks[c1.id] = c1 chunks[c2.id] = c2 chunks[c3.id] = c3 return chunks def _init_mock_models() -> dict[str, ModelProfile]: """初始化假数据模型配置""" models = {} mp1 = ModelProfile( id="MDL-001", vendor="华为", api_url="https://api.huawei.com/v1/chat", is_primary=True, weight=2, ) mp2 = ModelProfile( id="MDL-002", vendor="百度", api_url="https://api.baidu.com/v1/chat", is_primary=False, weight=1, ) models[mp1.id] = mp1 models[mp2.id] = mp2 return models def _init_mock_mcp_tools() -> dict[str, McpTool]: """初始化假数据MCP工具""" tools = {} t1 = McpTool( id="MCP-001", name="gjb_validator", description="GJB规则合规验证工具", json_schema={ "type": "object", "properties": { "document_id": {"type": "string", "description": "待验证文档ID"}, }, "required": ["document_id"], }, enabled=True, ) t2 = McpTool( id="MCP-002", name="llm_analyzer", description="大模型智能分析工具", json_schema={ "type": "object", "properties": { "prompt": {"type": "string", "description": "分析提示词"}, "model_id": {"type": "string", "description": "模型ID"}, }, "required": ["prompt"], }, enabled=True, ) tools[t1.id] = t1 tools[t2.id] = t2 return tools def _init_mock_workflows() -> dict[str, Workflow]: """初始化假数据工作流""" workflows = {} w1 = Workflow( id="WF-001", name="文档合规审查工作流", skill_ids=["SK-001", "SK-002"], logic={ "type": "sequential", "steps": [ {"skill_id": "SK-001", "on_success": "SK-002", "on_failure": "end"}, ], }, ) workflows[w1.id] = w1 return workflows # ============================================================================= # 服务类 # ============================================================================= class TemplateService: """文档模板管理服务（SRS-MACP_F-001）""" def __init__(self): self._templates = _init_mock_templates() def list_templates(self) -> list[Template]: """获取所有模板列表 Returns: list[Template]: 模板列表 """ return list(self._templates.values()) def get_template(self, template_id: str) -> Optional[Template]: """根据ID获取模板详情 Args: template_id: 模板ID Returns: Optional[Template]: 模板对象，不存在时返回None """ return self._templates.get(template_id) def create_template(self, template: Template) -> Template: """创建新模板 Args: template: 模板对象（不含ID时自动生成） Returns: Template: 创建后的模板 """ if not template.id: template.id = f"TPL-{uuid.uuid4().hex[:6].upper()}" template.created_at = datetime.now() self._templates[template.id] = template return template def delete_template(self, template_id: str) -> bool: """删除模板 Args: template_id: 模板ID Returns: bool: 是否删除成功 """ if template_id in self._templates: del self._templates[template_id] return True return False class DocumentService: """文档管理服务""" def __init__(self): self._documents = _init_mock_documents() def list_documents(self) -> list[Document]: """获取所有文档列表""" return list(self._documents.values()) def get_document(self, doc_id: str) -> Optional[Document]: """根据ID获取文档详情""" return self._documents.get(doc_id) def create_document(self, document: Document) -> Document: """创建新文档""" if not document.id: document.id = f"DOC-{uuid.uuid4().hex[:6].upper()}" document.created_at = datetime.now() document.updated_at = datetime.now() document.status = DocumentStatus.DRAFT self._documents[document.id] = document return document class GjbValidatorService: """GJB合规验证服务（SRS-MACP_F-002）""" def __init__(self): self._rules = _init_mock_rules() self._reports: dict[str, ValidationReport] = {} def list_rules(self) -> list[GjbRule]: """获取所有GJB规则""" return list(self._rules.values()) def validate_document(self, document: Document) -> ValidationReport: """对文档执行GJB合规验证 模拟校验文档结构、章节完整性与格式规范。 Args: document: 待验证文档 Returns: ValidationReport: 验证报告 """ report_id = f"VR-{uuid.uuid4().hex[:6].upper()}" non_compliant = [] compliant_count = 0 for rule in self._rules.values(): # 模拟校验逻辑：检查模板章节是否在文档内容中 found = rule.section in document.content or rule.requirement[:10] in document.content if found: compliant_count += 1 else: non_compliant.append({ "rule_id": rule.id, "section": rule.section, "requirement": rule.requirement, "severity": "critical" if rule.mandatory else "warning", "suggestion": rule.suggestion, }) report = ValidationReport( id=report_id, document_id=document.id, validated_at=datetime.now(), total_rules=len(self._rules), compliant_count=compliant_count, non_compliant_items=non_compliant, ) self._reports[report_id] = report return report def get_report(self, report_id: str) -> Optional[ValidationReport]: """获取验证报告""" return self._reports.get(report_id) class SkillService: """Skills流程编排服务（SRS-MACP_F-005）""" def __init__(self): self._skills = _init_mock_skills() self._workflows = _init_mock_workflows() def list_skills(self) -> list[Skill]: """获取所有Skill""" return list(self._skills.values()) def get_skill(self, skill_id: str) -> Optional[Skill]: """获取Skill详情""" return self._skills.get(skill_id) def create_skill(self, skill: Skill) -> Skill: """创建新Skill""" if not skill.id: skill.id = f"SK-{uuid.uuid4().hex[:6].upper()}" self._skills[skill.id] = skill return skill def execute_skill(self, skill_id: str, context: dict[str, Any]) -> dict[str, Any]: """模拟执行Skill Args: skill_id: Skill ID context: 执行上下文参数 Returns: dict: 执行结果 """ skill = self._skills.get(skill_id) if not skill: return {"success": False, "error": f"Skill {skill_id} not found"} return { "success": True, "skill_id": skill_id, "skill_name": skill.name, "result": f"已模拟执行Skill: {skill.name}，输入上下文: {context}", "executed_at": datetime.now().isoformat(), } def list_workflows(self) -> list[Workflow]: """获取所有工作流""" return list(self._workflows.values()) def create_workflow(self, workflow: Workflow) -> Workflow: """创建工作流""" if not workflow.id: workflow.id = f"WF-{uuid.uuid4().hex[:6].upper()}" self._workflows[workflow.id] = workflow return workflow class MemoryService: """智能体记忆管理服务（SRS-MACP_F-006）""" def __init__(self): self._memories = _init_mock_memories() def list_memories(self, session_id: Optional[str] = None) -> list[MemoryEntry]: """获取记忆列表，可按会话ID过滤""" if session_id: return [m for m in self._memories.values() if m.session_id == session_id] return list(self._memories.values()) def get_memory(self, memory_id: str) -> Optional[MemoryEntry]: """获取记忆详情""" return self._memories.get(memory_id) def create_memory(self, memory: MemoryEntry) -> MemoryEntry: """创建记忆条目""" if not memory.id: memory.id = f"MEM-{uuid.uuid4().hex[:6].upper()}" memory.created_at = datetime.now() self._memories[memory.id] = memory return memory def delete_memory(self, memory_id: str) -> bool: """删除记忆""" if memory_id in self._memories: del self._memories[memory_id] return True return False def search_memories(self, query: str) -> list[MemoryEntry]: """基于语义相似度检索相关记忆（模拟实现）""" results = [] for mem in self._memories.values(): if query.lower() in mem.summary.lower() or query.lower() in mem.original_dialogue.lower(): results.append(mem) return results class KnowledgeBaseService: """知识库交互服务（SRS-MACP_F-008）""" def __init__(self): self._chunks = _init_mock_knowledge() def list_chunks(self, level: Optional[KnowledgeLevel] = None) -> list[KnowledgeChunk]: """获取知识库片段列表，可按层级过滤""" if level: return [c for c in self._chunks.values() if c.level == level] return list(self._chunks.values()) def get_chunk(self, chunk_id: str) -> Optional[KnowledgeChunk]: """获取知识库片段详情""" return self._chunks.get(chunk_id) def search_chunks(self, query: str, top_k: int = 5) -> list[KnowledgeChunk]: """搜索知识库片段（模拟向量检索）""" ranked = [] for chunk in self._chunks.values(): score = 0 if query.lower() in chunk.content.lower(): score += 3 for tag in chunk.metadata_tags: if query.lower() in tag.lower(): score += 2 if query.lower() in chunk.source_document.lower(): score += 1 if score > 0: ranked.append((score, chunk)) ranked.sort(key=lambda x: -x[0]) return [item[1] for item in ranked[:top_k]] class ModelService: """统一大模型接入服务（SRS-MACP_F-009）""" def __init__(self): self._models = _init_mock_models() def list_models(self) -> list[ModelProfile]: """获取所有模型配置""" return list(self._models.values()) def get_primary_model(self) -> Optional[ModelProfile]: """获取主用模型""" for model in self._models.values(): if model.is_primary: return model return None def health_check(self, model_id: str) -> dict[str, Any]: """模拟模型健康检查""" model = self._models.get(model_id) if not model: return {"status": "unknown", "error": "Model not found"} return { "model_id": model_id, "vendor": model.vendor, "status": model.health_status.value, "healthy": model.health_status == ModelStatus.ACTIVE, "checked_at": datetime.now().isoformat(), } def failover(self, failed_model_id: str) -> Optional[ModelProfile]: """模拟故障转移""" failed = self._models.get(failed_model_id) if failed: failed.health_status = ModelStatus.FAILOVER failed.is_primary = False # 找下一个可用模型 for model in self._models.values(): if model.id != failed_model_id and model.health_status == ModelStatus.ACTIVE: model.is_primary = True return model return None class MultimodalService: """多模态输入处理服务（SRS-MACP_F-010）""" def __init__(self): self._results: dict[str, MultimodalResult] = {} def process_file(self, file_name: str, file_type: FileType) -> MultimodalResult: """模拟多模态文件处理 根据文件类型模拟OCR识别、语音转写、关键帧提取等处理。 Args: file_name: 文件名 file_type: 文件类型 Returns: MultimodalResult: 处理结果 """ result_id = f"MTR-{uuid.uuid4().hex[:6].upper()}" result = MultimodalResult( id=result_id, file_type=file_type, file_name=file_name, extracted_at=datetime.now(), ) if file_type == FileType.IMAGE: result.ocr_text = f"[模拟OCR识别结果] 从图片 {file_name} 中识别到文本内容。" elif file_type == FileType.AUDIO: result.asr_transcript = f"[模拟ASR转写结果] 从音频 {file_name} 中转写出语音文本。" elif file_type == FileType.VIDEO: result.ocr_text = f"[模拟视频OCR] 从视频 {file_name} 中提取到字幕文本。" result.asr_transcript = f"[模拟视频ASR] 从视频 {file_name} 中转写出语音文本。" result.key_frames = [f"{file_name}_frame_001.jpg", f"{file_name}_frame_002.jpg"] self._results[result_id] = result return result def get_result(self, result_id: str) -> Optional[MultimodalResult]: """获取处理结果""" return self._results.get(result_id) class SandboxService: """安全沙箱执行服务（SRS-MACP_F-007）""" def __init__(self): self._execution_logs: list[dict[str, Any]] = [] def execute_code(self, code: str, language: str = "python") -> dict[str, Any]: """模拟沙箱环境执行代码 Args: code: 待执行代码 language: 编程语言 Returns: dict: 执行结果，包含输出、日志、执行时间等 """ execution_id = f"SBX-{uuid.uuid4().hex[:6].upper()}" log_entry = { "execution_id": execution_id, "language": language, "code_length": len(code), "started_at": datetime.now().isoformat(), "status": "completed", } # 模拟执行结果（沙箱内真实执行有安全风险，此处仅模拟） result = { "execution_id": execution_id, "language": language, "status": "completed", "stdout": f"[模拟沙箱执行] 已安全执行{language}代码，长度{len(code)}字符。\n资源限制：CPU 1核，内存 512MB，网络隔离。", "stderr": "", "execution_time_ms": 120, "resource_usage": { "cpu_percent": 45.0, "memory_mb": 128.0, }, "executed_at": datetime.now().isoformat(), } log_entry["status"] = "completed" log_entry["finished_at"] = datetime.now().isoformat() self._execution_logs.append(log_entry) return result def get_execution_logs(self) -> list[dict[str, Any]]: """获取沙箱执行日志""" return self._execution_logs class McpToolService: """MCP工具接入服务（SRS-MACP_F-004）""" def __init__(self): self._tools = _init_mock_mcp_tools() def list_tools(self) -> list[McpTool]: """获取所有MCP工具""" return list(self._tools.values()) def get_tool(self, tool_id: str) -> Optional[McpTool]: """获取MCP工具详情""" return self._tools.get(tool_id) def register_tool(self, tool: McpTool) -> McpTool: """注册MCP工具""" if not tool.id: tool.id = f"MCP-{uuid.uuid4().hex[:6].upper()}" tool.created_at = datetime.now() self._tools[tool.id] = tool return tool def delete_tool(self, tool_id: str) -> bool: """删除MCP工具""" if tool_id in self._tools: del self._tools[tool_id] return True return False def debug_tool(self, tool_id: str, input_data: dict[str, Any]) -> dict[str, Any]: """沙箱调试MCP工具 Args: tool_id: 工具ID input_data: 调试输入数据 Returns: dict: 调试结果 """ tool = self._tools.get(tool_id) if not tool: return {"success": False, "error": f"Tool {tool_id} not found"} return { "success": True, "tool_id": tool_id, "tool_name": tool.name, "input": input_data, "output": {"result": f"[模拟MCP工具调试] 工具 '{tool.name}' 执行成功"}, "debug_log": ["初始化工具上下文...", f"验证JSON Schema...", "执行工具逻辑...", "返回结果"], }