#!/usr/bin/env python3 """ InsightFlow Backend - Phase 6 (API Platform) API 开放平台：API Key 管理、Swagger 文档、限流 Knowledge Growth: Multi-file fusion + Entity Alignment + Document Import ASR: 阿里云听悟 + OSS """ import os import sys import json import hashlib import secrets import httpx import uuid import re import io import time from fastapi import FastAPI, File, UploadFile, HTTPException, Form, Depends, Header, Request from fastapi.middleware.cors import CORSMiddleware from fastapi.staticfiles import StaticFiles from fastapi.responses import JSONResponse from pydantic import BaseModel, Field from typing import List, Optional, Union, Dict from datetime import datetime # Add backend directory to path for imports backend_dir = os.path.dirname(os.path.abspath(__file__)) if backend_dir not in sys.path: sys.path.insert(0, backend_dir) # Import clients try: from oss_uploader import get_oss_uploader OSS_AVAILABLE = True except ImportError: OSS_AVAILABLE = False try: from tingwu_client import TingwuClient TINGWU_AVAILABLE = True except ImportError: TINGWU_AVAILABLE = False try: from db_manager import get_db_manager, Project, Entity, EntityMention DB_AVAILABLE = True except ImportError as e: print(f"DB import error: {e}") DB_AVAILABLE = False try: from document_processor import DocumentProcessor DOC_PROCESSOR_AVAILABLE = True except ImportError: DOC_PROCESSOR_AVAILABLE = False try: from entity_aligner import EntityAligner ALIGNER_AVAILABLE = True except ImportError: ALIGNER_AVAILABLE = False try: from llm_client import get_llm_client, ChatMessage LLM_CLIENT_AVAILABLE = True except ImportError: LLM_CLIENT_AVAILABLE = False try: from knowledge_reasoner import get_knowledge_reasoner, KnowledgeReasoner, ReasoningType REASONER_AVAILABLE = True except ImportError: REASONER_AVAILABLE = False try: from export_manager import get_export_manager, ExportEntity, ExportRelation, ExportTranscript EXPORT_AVAILABLE = True except ImportError: EXPORT_AVAILABLE = False try: from neo4j_manager import get_neo4j_manager, sync_project_to_neo4j, NEO4J_AVAILABLE except ImportError: NEO4J_AVAILABLE = False # Phase 6: API Key Manager try: from api_key_manager import get_api_key_manager, ApiKeyManager, ApiKey API_KEY_AVAILABLE = True except ImportError as e: print(f"API Key Manager import error: {e}") API_KEY_AVAILABLE = False # Phase 6: Rate Limiter try: from rate_limiter import get_rate_limiter, RateLimitConfig, RateLimitInfo RATE_LIMITER_AVAILABLE = True except ImportError as e: print(f"Rate Limiter import error: {e}") RATE_LIMITER_AVAILABLE = False # Phase 7: Workflow Manager try: from workflow_manager import ( get_workflow_manager, WorkflowManager, Workflow, WorkflowTask, WebhookConfig, WorkflowLog, WorkflowType, WebhookType, TaskStatus ) WORKFLOW_AVAILABLE = True except ImportError as e: print(f"Workflow Manager import error: {e}") WORKFLOW_AVAILABLE = False # Phase 7: Multimodal Support try: from multimodal_processor import ( get_multimodal_processor, MultimodalProcessor, VideoProcessingResult, VideoFrame ) MULTIMODAL_AVAILABLE = True except ImportError as e: print(f"Multimodal Processor import error: {e}") MULTIMODAL_AVAILABLE = False try: from image_processor import ( get_image_processor, ImageProcessor, ImageProcessingResult, ImageEntity, ImageRelation ) IMAGE_PROCESSOR_AVAILABLE = True except ImportError as e: print(f"Image Processor import error: {e}") IMAGE_PROCESSOR_AVAILABLE = False try: from multimodal_entity_linker import ( get_multimodal_entity_linker, MultimodalEntityLinker, MultimodalEntity, EntityLink, AlignmentResult, FusionResult ) MULTIMODAL_LINKER_AVAILABLE = True except ImportError as e: print(f"Multimodal Entity Linker import error: {e}") MULTIMODAL_LINKER_AVAILABLE = False # Phase 7 Task 7: Plugin Manager try: from plugin_manager import ( get_plugin_manager, PluginManager, Plugin, BotSession, WebhookEndpoint, WebDAVSync, PluginType, PluginStatus, ChromeExtensionHandler, BotHandler, WebhookIntegration ) PLUGIN_MANAGER_AVAILABLE = True except ImportError as e: print(f"Plugin Manager import error: {e}") PLUGIN_MANAGER_AVAILABLE = False # FastAPI app with enhanced metadata for Swagger app = FastAPI( title="InsightFlow API", description=""" InsightFlow 知识管理平台 API ## 功能 * **项目管理** - 创建、读取、更新、删除项目 * **实体管理** - 实体提取、对齐、属性管理 * **关系管理** - 实体关系创建、查询、分析 * **转录管理** - 音频转录、文档导入 * **知识推理** - 因果推理、对比分析、时序分析 * **图分析** - Neo4j 图数据库集成、路径查询 * **导出功能** - 多种格式导出（PDF、Excel、CSV、JSON） * **工作流** - 自动化任务、Webhook 通知 ## 认证 大部分 API 需要 API Key 认证。在请求头中添加： ``` X-API-Key: your_api_key_here ``` """, version="0.7.0", contact={ "name": "InsightFlow Team", "url": "https://github.com/insightflow/insightflow", }, license_info={ "name": "MIT", "url": "https://opensource.org/licenses/MIT", }, openapi_tags=[ {"name": "Projects", "description": "项目管理"}, {"name": "Entities", "description": "实体管理"}, {"name": "Relations", "description": "关系管理"}, {"name": "Transcripts", "description": "转录管理"}, {"name": "Analysis", "description": "分析和推理"}, {"name": "Graph", "description": "图分析和 Neo4j"}, {"name": "Export", "description": "数据导出"}, {"name": "API Keys", "description": "API 密钥管理"}, {"name": "Workflows", "description": "工作流自动化"}, {"name": "Webhooks", "description": "Webhook 配置"}, {"name": "Multimodal", "description": "多模态支持（视频、图片）"}, {"name": "Plugins", "description": "插件管理"}, {"name": "Chrome Extension", "description": "Chrome 扩展集成"}, {"name": "Bot", "description": "飞书/钉钉机器人"}, {"name": "Integrations", "description": "Zapier/Make 集成"}, {"name": "WebDAV", "description": "WebDAV 同步"}, {"name": "System", "description": "系统信息"}, ] ) app.add_middleware( CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) # ==================== Phase 6: API Key Authentication & Rate Limiting ==================== # 公开访问的路径（不需要 API Key） PUBLIC_PATHS = { "/", "/docs", "/openapi.json", "/redoc", "/api/v1/health", "/api/v1/status", "/api/v1/api-keys", # POST 创建 API Key 不需要认证 } # 管理路径（需要 master key） ADMIN_PATHS = { "/api/v1/admin/", } # Master Key（用于管理所有 API Keys） MASTER_KEY = os.getenv("INSIGHTFLOW_MASTER_KEY", "") async def verify_api_key(request: Request, x_api_key: Optional[str] = Header(None, alias="X-API-Key")): """ 验证 API Key 的依赖函数 - 公开路径不需要认证 - 管理路径需要 master key - 其他路径需要有效的 API Key """ path = request.url.path method = request.method # 公开路径直接放行 if any(path.startswith(p) for p in PUBLIC_PATHS): return None # 创建 API Key 的端点不需要认证（但需要 master key 或其他验证） if path == "/api/v1/api-keys" and method == "POST": return None # 检查是否是管理路径 if any(path.startswith(p) for p in ADMIN_PATHS): if not x_api_key or x_api_key != MASTER_KEY: raise HTTPException( status_code=403, detail="Admin access required. Provide valid master key in X-API-Key header." ) return {"type": "admin", "key": x_api_key} # 其他路径需要有效的 API Key if not API_KEY_AVAILABLE: # API Key 模块不可用，允许访问（开发模式） return None if not x_api_key: raise HTTPException( status_code=401, detail="API Key required. Provide your key in X-API-Key header.", headers={"WWW-Authenticate": "ApiKey"} ) # 验证 API Key key_manager = get_api_key_manager() api_key = key_manager.validate_key(x_api_key) if not api_key: raise HTTPException( status_code=401, detail="Invalid or expired API Key" ) # 更新最后使用时间 key_manager.update_last_used(api_key.id) # 将 API Key 信息存储在请求状态中，供后续使用 request.state.api_key = api_key return {"type": "api_key", "key_id": api_key.id, "permissions": api_key.permissions} async def rate_limit_middleware(request: Request, call_next): """ 限流中间件 """ if not RATE_LIMITER_AVAILABLE or not API_KEY_AVAILABLE: response = await call_next(request) return response path = request.url.path # 公开路径不限流 if any(path.startswith(p) for p in PUBLIC_PATHS): response = await call_next(request) return response # 获取限流键 limiter = get_rate_limiter() # 检查是否有 API Key x_api_key = request.headers.get("X-API-Key") if x_api_key and x_api_key == MASTER_KEY: # Master key 有更高的限流 config = RateLimitConfig(requests_per_minute=1000) limit_key = f"master:{x_api_key[:16]}" elif hasattr(request.state, 'api_key') and request.state.api_key: # 使用 API Key 的限流配置 api_key = request.state.api_key config = RateLimitConfig(requests_per_minute=api_key.rate_limit) limit_key = f"api_key:{api_key.id}" else: # IP 限流（未认证用户） client_ip = request.client.host if request.client else "unknown" config = RateLimitConfig(requests_per_minute=10) limit_key = f"ip:{client_ip}" # 检查限流 info = await limiter.is_allowed(limit_key, config) if not info.allowed: return JSONResponse( status_code=429, content={ "error": "Rate limit exceeded", "retry_after": info.retry_after, "limit": config.requests_per_minute, "window": "minute" }, headers={ "X-RateLimit-Limit": str(config.requests_per_minute), "X-RateLimit-Remaining": "0", "X-RateLimit-Reset": str(info.reset_time), "Retry-After": str(info.retry_after) } ) # 继续处理请求 start_time = time.time() response = await call_next(request) # 添加限流头 response.headers["X-RateLimit-Limit"] = str(config.requests_per_minute) response.headers["X-RateLimit-Remaining"] = str(info.remaining) response.headers["X-RateLimit-Reset"] = str(info.reset_time) # 记录 API 调用日志 try: if hasattr(request.state, 'api_key') and request.state.api_key: api_key = request.state.api_key response_time = int((time.time() - start_time) * 1000) key_manager = get_api_key_manager() key_manager.log_api_call( api_key_id=api_key.id, endpoint=path, method=request.method, status_code=response.status_code, response_time_ms=response_time, ip_address=request.client.host if request.client else "", user_agent=request.headers.get("User-Agent", "") ) except Exception as e: # 日志记录失败不应影响主流程 print(f"Failed to log API call: {e}") return response # 添加限流中间件 app.middleware("http")(rate_limit_middleware) # ==================== Phase 6: Pydantic Models for API ==================== # API Key 相关模型 class ApiKeyCreate(BaseModel): name: str = Field(..., description="API Key 名称/描述") permissions: List[str] = Field(default=["read"], description="权限列表: read, write, delete") rate_limit: int = Field(default=60, description="每分钟请求限制") expires_days: Optional[int] = Field(default=None, description="过期天数（可选）") class ApiKeyResponse(BaseModel): id: str key_preview: str name: str permissions: List[str] rate_limit: int status: str created_at: str expires_at: Optional[str] last_used_at: Optional[str] total_calls: int class ApiKeyCreateResponse(BaseModel): api_key: str = Field(..., description="API Key（仅显示一次，请妥善保存）") info: ApiKeyResponse class ApiKeyListResponse(BaseModel): keys: List[ApiKeyResponse] total: int class ApiKeyUpdate(BaseModel): name: Optional[str] = None permissions: Optional[List[str]] = None rate_limit: Optional[int] = None class ApiCallStats(BaseModel): total_calls: int success_calls: int error_calls: int avg_response_time_ms: float max_response_time_ms: int min_response_time_ms: int class ApiStatsResponse(BaseModel): summary: ApiCallStats endpoints: List[Dict] daily: List[Dict] class ApiCallLog(BaseModel): id: int endpoint: str method: str status_code: int response_time_ms: int ip_address: str user_agent: str error_message: str created_at: str class ApiLogsResponse(BaseModel): logs: List[ApiCallLog] total: int class RateLimitStatus(BaseModel): limit: int remaining: int reset_time: int window: str # 原有模型（保留） class EntityModel(BaseModel): id: str name: str type: str definition: Optional[str] = "" aliases: List[str] = [] class TranscriptSegment(BaseModel): start: float end: float text: str speaker: Optional[str] = "Speaker A" class AnalysisResult(BaseModel): transcript_id: str project_id: str segments: List[TranscriptSegment] entities: List[EntityModel] full_text: str created_at: str class ProjectCreate(BaseModel): name: str description: str = "" class EntityUpdate(BaseModel): name: Optional[str] = None type: Optional[str] = None definition: Optional[str] = None aliases: Optional[List[str]] = None class RelationCreate(BaseModel): source_entity_id: str target_entity_id: str relation_type: str evidence: Optional[str] = "" class TranscriptUpdate(BaseModel): full_text: str class AgentQuery(BaseModel): query: str stream: bool = False class AgentCommand(BaseModel): command: str class EntityMergeRequest(BaseModel): source_entity_id: str target_entity_id: str class GlossaryTermCreate(BaseModel): term: str pronunciation: Optional[str] = "" # ==================== Phase 7: Workflow Pydantic Models ==================== class WorkflowCreate(BaseModel): name: str = Field(..., description="工作流名称") description: str = Field(default="", description="工作流描述") workflow_type: str = Field(..., description="工作流类型: auto_analyze, auto_align, auto_relation, scheduled_report, custom") project_id: str = Field(..., description="所属项目ID") schedule: Optional[str] = Field(default=None, description="调度表达式(cron或分钟数)") schedule_type: str = Field(default="manual", description="调度类型: manual, cron, interval") config: Dict = Field(default_factory=dict, description="工作流配置") webhook_ids: List[str] = Field(default_factory=list, description="关联的Webhook ID列表") class WorkflowUpdate(BaseModel): name: Optional[str] = None description: Optional[str] = None status: Optional[str] = None # active, paused, error, completed schedule: Optional[str] = None schedule_type: Optional[str] = None is_active: Optional[bool] = None config: Optional[Dict] = None webhook_ids: Optional[List[str]] = None class WorkflowResponse(BaseModel): id: str name: str description: str workflow_type: str project_id: str status: str schedule: Optional[str] schedule_type: str config: Dict webhook_ids: List[str] is_active: bool created_at: str updated_at: str last_run_at: Optional[str] next_run_at: Optional[str] run_count: int success_count: int fail_count: int class WorkflowListResponse(BaseModel): workflows: List[WorkflowResponse] total: int class WorkflowTaskCreate(BaseModel): name: str = Field(..., description="任务名称") task_type: str = Field(..., description="任务类型: analyze, align, discover_relations, notify, custom") config: Dict = Field(default_factory=dict, description="任务配置") order: int = Field(default=0, description="执行顺序") depends_on: List[str] = Field(default_factory=list, description="依赖的任务ID列表") timeout_seconds: int = Field(default=300, description="超时时间(秒)") retry_count: int = Field(default=3, description="重试次数") retry_delay: int = Field(default=5, description="重试延迟(秒)") class WorkflowTaskUpdate(BaseModel): name: Optional[str] = None task_type: Optional[str] = None config: Optional[Dict] = None order: Optional[int] = None depends_on: Optional[List[str]] = None timeout_seconds: Optional[int] = None retry_count: Optional[int] = None retry_delay: Optional[int] = None class WorkflowTaskResponse(BaseModel): id: str workflow_id: str name: str task_type: str config: Dict order: int depends_on: List[str] timeout_seconds: int retry_count: int retry_delay: int created_at: str updated_at: str class WebhookCreate(BaseModel): name: str = Field(..., description="Webhook名称") webhook_type: str = Field(..., description="Webhook类型: feishu, dingtalk, slack, custom") url: str = Field(..., description="Webhook URL") secret: str = Field(default="", description="签名密钥") headers: Dict = Field(default_factory=dict, description="自定义请求头") template: str = Field(default="", description="消息模板") class WebhookUpdate(BaseModel): name: Optional[str] = None webhook_type: Optional[str] = None url: Optional[str] = None secret: Optional[str] = None headers: Optional[Dict] = None template: Optional[str] = None is_active: Optional[bool] = None class WebhookResponse(BaseModel): id: str name: str webhook_type: str url: str headers: Dict template: str is_active: bool created_at: str updated_at: str last_used_at: Optional[str] success_count: int fail_count: int class WebhookListResponse(BaseModel): webhooks: List[WebhookResponse] total: int class WorkflowLogResponse(BaseModel): id: str workflow_id: str task_id: Optional[str] status: str start_time: Optional[str] end_time: Optional[str] duration_ms: int input_data: Dict output_data: Dict error_message: str created_at: str class WorkflowLogListResponse(BaseModel): logs: List[WorkflowLogResponse] total: int class WorkflowTriggerRequest(BaseModel): input_data: Dict = Field(default_factory=dict, description="工作流输入数据") class WorkflowTriggerResponse(BaseModel): success: bool workflow_id: str log_id: str results: Dict duration_ms: int class WorkflowStatsResponse(BaseModel): total: int success: int failed: int success_rate: float avg_duration_ms: float daily: List[Dict] # API Keys KIMI_API_KEY = os.getenv("KIMI_API_KEY", "") KIMI_BASE_URL = os.getenv("KIMI_BASE_URL", "https://api.kimi.com/coding") # Phase 3: Entity Aligner singleton _aligner = None def get_aligner(): global _aligner if _aligner is None and ALIGNER_AVAILABLE: _aligner = EntityAligner() return _aligner # Phase 3: Document Processor singleton _doc_processor = None def get_doc_processor(): global _doc_processor if _doc_processor is None and DOC_PROCESSOR_AVAILABLE: _doc_processor = DocumentProcessor() return _doc_processor # Phase 2: Entity Edit API @app.put("/api/v1/entities/{entity_id}", tags=["Entities"]) async def update_entity(entity_id: str, update: EntityUpdate, _=Depends(verify_api_key)): """更新实体信息（名称、类型、定义、别名）""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() entity = db.get_entity(entity_id) if not entity: raise HTTPException(status_code=404, detail="Entity not found") # 更新字段 update_data = {k: v for k, v in update.dict().items() if v is not None} updated = db.update_entity(entity_id, **update_data) return { "id": updated.id, "name": updated.name, "type": updated.type, "definition": updated.definition, "aliases": updated.aliases } @app.delete("/api/v1/entities/{entity_id}", tags=["Entities"]) async def delete_entity(entity_id: str, _=Depends(verify_api_key)): """删除实体""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() entity = db.get_entity(entity_id) if not entity: raise HTTPException(status_code=404, detail="Entity not found") db.delete_entity(entity_id) return {"success": True, "message": f"Entity {entity_id} deleted"} @app.post("/api/v1/entities/{entity_id}/merge", tags=["Entities"]) async def merge_entities_endpoint(entity_id: str, merge_req: EntityMergeRequest, _=Depends(verify_api_key)): """合并两个实体""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() # 验证两个实体都存在 source = db.get_entity(merge_req.source_entity_id) target = db.get_entity(merge_req.target_entity_id) if not source or not target: raise HTTPException(status_code=404, detail="Entity not found") result = db.merge_entities(merge_req.target_entity_id, merge_req.source_entity_id) return { "success": True, "merged_entity": { "id": result.id, "name": result.name, "type": result.type, "definition": result.definition, "aliases": result.aliases } } # Phase 2: Relation Edit API @app.post("/api/v1/projects/{project_id}/relations", tags=["Relations"]) async def create_relation_endpoint(project_id: str, relation: RelationCreate, _=Depends(verify_api_key)): """创建新的实体关系""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() # 验证实体存在 source = db.get_entity(relation.source_entity_id) target = db.get_entity(relation.target_entity_id) if not source or not target: raise HTTPException(status_code=404, detail="Source or target entity not found") relation_id = db.create_relation( project_id=project_id, source_entity_id=relation.source_entity_id, target_entity_id=relation.target_entity_id, relation_type=relation.relation_type, evidence=relation.evidence ) return { "id": relation_id, "source_id": relation.source_entity_id, "target_id": relation.target_entity_id, "type": relation.relation_type, "success": True } @app.delete("/api/v1/relations/{relation_id}", tags=["Relations"]) async def delete_relation(relation_id: str, _=Depends(verify_api_key)): """删除关系""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() db.delete_relation(relation_id) return {"success": True, "message": f"Relation {relation_id} deleted"} @app.put("/api/v1/relations/{relation_id}", tags=["Relations"]) async def update_relation(relation_id: str, relation: RelationCreate, _=Depends(verify_api_key)): """更新关系""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() updated = db.update_relation( relation_id=relation_id, relation_type=relation.relation_type, evidence=relation.evidence ) return { "id": relation_id, "type": updated["relation_type"], "evidence": updated["evidence"], "success": True } # Phase 2: Transcript Edit API @app.get("/api/v1/transcripts/{transcript_id}", tags=["Transcripts"]) async def get_transcript(transcript_id: str, _=Depends(verify_api_key)): """获取转录详情""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() transcript = db.get_transcript(transcript_id) if not transcript: raise HTTPException(status_code=404, detail="Transcript not found") return transcript @app.put("/api/v1/transcripts/{transcript_id}", tags=["Transcripts"]) async def update_transcript(transcript_id: str, update: TranscriptUpdate, _=Depends(verify_api_key)): """更新转录文本（人工修正）""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() transcript = db.get_transcript(transcript_id) if not transcript: raise HTTPException(status_code=404, detail="Transcript not found") updated = db.update_transcript(transcript_id, update.full_text) return { "id": transcript_id, "full_text": updated["full_text"], "updated_at": updated["updated_at"], "success": True } # Phase 2: Manual Entity Creation class ManualEntityCreate(BaseModel): name: str type: str = "OTHER" definition: str = "" transcript_id: Optional[str] = None start_pos: Optional[int] = None end_pos: Optional[int] = None @app.post("/api/v1/projects/{project_id}/entities", tags=["Entities"]) async def create_manual_entity(project_id: str, entity: ManualEntityCreate, _=Depends(verify_api_key)): """手动创建实体（划词新建）""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() # 检查是否已存在 existing = db.get_entity_by_name(project_id, entity.name) if existing: return { "id": existing.id, "name": existing.name, "type": existing.type, "existed": True } entity_id = str(uuid.uuid4())[:8] new_entity = db.create_entity(Entity( id=entity_id, project_id=project_id, name=entity.name, type=entity.type, definition=entity.definition )) # 如果有提及位置信息，保存提及 if entity.transcript_id and entity.start_pos is not None and entity.end_pos is not None: transcript = db.get_transcript(entity.transcript_id) if transcript: text = transcript["full_text"] mention = EntityMention( id=str(uuid.uuid4())[:8], entity_id=entity_id, transcript_id=entity.transcript_id, start_pos=entity.start_pos, end_pos=entity.end_pos, text_snippet=text[max(0, entity.start_pos-20):min(len(text), entity.end_pos+20)], confidence=1.0 ) db.add_mention(mention) return { "id": new_entity.id, "name": new_entity.name, "type": new_entity.type, "definition": new_entity.definition, "success": True } def transcribe_audio(audio_data: bytes, filename: str) -> dict: """转录音频：OSS上传 + 听悟转录""" # 1. 上传 OSS if not OSS_AVAILABLE: print("OSS not available, using mock") return mock_transcribe() try: uploader = get_oss_uploader() audio_url, object_name = uploader.upload_audio(audio_data, filename) print(f"Uploaded to OSS: {object_name}") except Exception as e: print(f"OSS upload failed: {e}") return mock_transcribe() # 2. 听悟转录 if not TINGWU_AVAILABLE: print("Tingwu not available, using mock") return mock_transcribe() try: client = TingwuClient() result = client.transcribe(audio_url) print(f"Transcription complete: {len(result['segments'])} segments") return result except Exception as e: print(f"Tingwu failed: {e}") return mock_transcribe() def mock_transcribe() -> dict: """Mock 转录结果""" return { "full_text": "我们今天讨论 Project Alpha 的进度，K8s 集群已经部署完成。", "segments": [ {"start": 0.0, "end": 5.0, "text": "我们今天讨论 Project Alpha 的进度，K8s 集群已经部署完成。", "speaker": "Speaker A"} ] } def extract_entities_with_llm(text: str) -> tuple[List[dict], List[dict]]: """使用 Kimi API 提取实体和关系 Returns: (entities, relations): 实体列表和关系列表 """ if not KIMI_API_KEY or not text: return [], [] prompt = f"""从以下会议文本中提取关键实体和它们之间的关系，以 JSON 格式返回： 文本：{text[:3000]} 要求： 1. entities: 每个实体包含 name(名称), type(类型: PROJECT/TECH/PERSON/ORG/OTHER), definition(一句话定义) 2. relations: 每个关系包含 source(源实体名), target(目标实体名), type(关系类型: belongs_to/works_with/depends_on/mentions/related) 3. 只返回 JSON 对象，格式: {{"entities": [...], "relations": [...]}} 示例： {{ "entities": [ {{"name": "Project Alpha", "type": "PROJECT", "definition": "核心项目"}}, {{"name": "K8s", "type": "TECH", "definition": "Kubernetes容器编排平台"}} ], "relations": [ {{"source": "Project Alpha", "target": "K8s", "type": "depends_on"}} ] }} """ try: response = httpx.post( f"{KIMI_BASE_URL}/v1/chat/completions", headers={"Authorization": f"Bearer {KIMI_API_KEY}", "Content-Type": "application/json"}, json={"model": "k2p5", "messages": [{"role": "user", "content": prompt}], "temperature": 0.1}, timeout=60.0 ) response.raise_for_status() result = response.json() content = result["choices"][0]["message"]["content"] import re json_match = re.search(r'\{{.*?\}}', content, re.DOTALL) if json_match: data = json.loads(json_match.group()) return data.get("entities", []), data.get("relations", []) except Exception as e: print(f"LLM extraction failed: {e}") return [], [] def align_entity(project_id: str, name: str, db, definition: str = "") -> Optional['Entity']: """实体对齐 - Phase 3: 使用 embedding 对齐""" # 1. 首先尝试精确匹配 existing = db.get_entity_by_name(project_id, name) if existing: return existing # 2. 使用 embedding 对齐（如果可用） aligner = get_aligner() if aligner: similar = aligner.find_similar_entity(project_id, name, definition) if similar: return similar # 3. 回退到简单相似度匹配 similar = db.find_similar_entities(project_id, name) if similar: return similar[0] return None # API Endpoints @app.post("/api/v1/projects", response_model=dict, tags=["Projects"]) async def create_project(project: ProjectCreate, _=Depends(verify_api_key)): """创建新项目""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() project_id = str(uuid.uuid4())[:8] p = db.create_project(project_id, project.name, project.description) return {"id": p.id, "name": p.name, "description": p.description} @app.get("/api/v1/projects", tags=["Projects"]) async def list_projects(_=Depends(verify_api_key)): """列出所有项目""" if not DB_AVAILABLE: return [] db = get_db_manager() projects = db.list_projects() return [{"id": p.id, "name": p.name, "description": p.description} for p in projects] @app.post("/api/v1/projects/{project_id}/upload", response_model=AnalysisResult, tags=["Projects"]) async def upload_audio(project_id: str, file: UploadFile = File(...), _=Depends(verify_api_key)): """上传音频到指定项目 - Phase 3: 支持多文件融合""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") content = await file.read() # 转录 print(f"Processing: {file.filename}") tw_result = transcribe_audio(content, file.filename) # 提取实体和关系 print("Extracting entities and relations...") raw_entities, raw_relations = extract_entities_with_llm(tw_result["full_text"]) # 保存转录记录 transcript_id = str(uuid.uuid4())[:8] db.save_transcript( transcript_id=transcript_id, project_id=project_id, filename=file.filename, full_text=tw_result["full_text"] ) # 实体对齐并保存 - Phase 3: 使用增强对齐 aligned_entities = [] entity_name_to_id = {} # 用于关系映射 for raw_ent in raw_entities: existing = align_entity(project_id, raw_ent["name"], db, raw_ent.get("definition", "")) if existing: ent_model = EntityModel( id=existing.id, name=existing.name, type=existing.type, definition=existing.definition, aliases=existing.aliases ) entity_name_to_id[raw_ent["name"]] = existing.id else: new_ent = db.create_entity(Entity( id=str(uuid.uuid4())[:8], project_id=project_id, name=raw_ent["name"], type=raw_ent.get("type", "OTHER"), definition=raw_ent.get("definition", "") )) ent_model = EntityModel( id=new_ent.id, name=new_ent.name, type=new_ent.type, definition=new_ent.definition ) entity_name_to_id[raw_ent["name"]] = new_ent.id aligned_entities.append(ent_model) # 保存实体提及位置 full_text = tw_result["full_text"] name = raw_ent["name"] start_pos = 0 while True: pos = full_text.find(name, start_pos) if pos == -1: break mention = EntityMention( id=str(uuid.uuid4())[:8], entity_id=entity_name_to_id[name], transcript_id=transcript_id, start_pos=pos, end_pos=pos + len(name), text_snippet=full_text[max(0, pos-20):min(len(full_text), pos+len(name)+20)], confidence=1.0 ) db.add_mention(mention) start_pos = pos + 1 # 保存关系 for rel in raw_relations: source_id = entity_name_to_id.get(rel.get("source", "")) target_id = entity_name_to_id.get(rel.get("target", "")) if source_id and target_id: db.create_relation( project_id=project_id, source_entity_id=source_id, target_entity_id=target_id, relation_type=rel.get("type", "related"), evidence=tw_result["full_text"][:200], transcript_id=transcript_id ) # 构建片段 segments = [TranscriptSegment(**seg) for seg in tw_result["segments"]] return AnalysisResult( transcript_id=transcript_id, project_id=project_id, segments=segments, entities=aligned_entities, full_text=tw_result["full_text"], created_at=datetime.now().isoformat() ) # Phase 3: Document Upload API @app.post("/api/v1/projects/{project_id}/upload-document") async def upload_document(project_id: str, file: UploadFile = File(...), _=Depends(verify_api_key)): """上传 PDF/DOCX 文档到指定项目""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") if not DOC_PROCESSOR_AVAILABLE: raise HTTPException(status_code=500, detail="Document processor not available") db = get_db_manager() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") content = await file.read() # 处理文档 processor = get_doc_processor() try: result = processor.process(content, file.filename) except Exception as e: raise HTTPException(status_code=400, detail=f"Document processing failed: {str(e)}") # 保存文档转录记录 transcript_id = str(uuid.uuid4())[:8] db.save_transcript( transcript_id=transcript_id, project_id=project_id, filename=file.filename, full_text=result["text"], transcript_type="document" ) # 提取实体和关系 raw_entities, raw_relations = extract_entities_with_llm(result["text"]) # 实体对齐并保存 aligned_entities = [] entity_name_to_id = {} for raw_ent in raw_entities: existing = align_entity(project_id, raw_ent["name"], db, raw_ent.get("definition", "")) if existing: entity_name_to_id[raw_ent["name"]] = existing.id aligned_entities.append(EntityModel( id=existing.id, name=existing.name, type=existing.type, definition=existing.definition, aliases=existing.aliases )) else: new_ent = db.create_entity(Entity( id=str(uuid.uuid4())[:8], project_id=project_id, name=raw_ent["name"], type=raw_ent.get("type", "OTHER"), definition=raw_ent.get("definition", "") )) entity_name_to_id[raw_ent["name"]] = new_ent.id aligned_entities.append(EntityModel( id=new_ent.id, name=new_ent.name, type=new_ent.type, definition=new_ent.definition )) # 保存实体提及位置 full_text = result["text"] name = raw_ent["name"] start_pos = 0 while True: pos = full_text.find(name, start_pos) if pos == -1: break mention = EntityMention( id=str(uuid.uuid4())[:8], entity_id=entity_name_to_id[name], transcript_id=transcript_id, start_pos=pos, end_pos=pos + len(name), text_snippet=full_text[max(0, pos-20):min(len(full_text), pos+len(name)+20)], confidence=1.0 ) db.add_mention(mention) start_pos = pos + 1 # 保存关系 for rel in raw_relations: source_id = entity_name_to_id.get(rel.get("source", "")) target_id = entity_name_to_id.get(rel.get("target", "")) if source_id and target_id: db.create_relation( project_id=project_id, source_entity_id=source_id, target_entity_id=target_id, relation_type=rel.get("type", "related"), evidence=result["text"][:200], transcript_id=transcript_id ) return { "transcript_id": transcript_id, "project_id": project_id, "filename": file.filename, "text_length": len(result["text"]), "entities": [e.dict() for e in aligned_entities], "created_at": datetime.now().isoformat() } # Phase 3: Knowledge Base API @app.get("/api/v1/projects/{project_id}/knowledge-base") async def get_knowledge_base(project_id: str, _=Depends(verify_api_key)): """获取项目知识库 - 包含所有实体、关系、术语表""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") # 获取所有实体 entities = db.list_project_entities(project_id) # 获取所有关系 relations = db.list_project_relations(project_id) # 获取所有转录 transcripts = db.list_project_transcripts(project_id) # 获取术语表 glossary = db.list_glossary(project_id) # 构建实体统计和属性 entity_stats = {} entity_attributes = {} for ent in entities: mentions = db.get_entity_mentions(ent.id) entity_stats[ent.id] = { "mention_count": len(mentions), "transcript_ids": list(set([m.transcript_id for m in mentions])) } # Phase 5: 获取实体属性 attrs = db.get_entity_attributes(ent.id) entity_attributes[ent.id] = attrs # 构建实体名称映射 entity_map = {e.id: e.name for e in entities} return { "project": { "id": project.id, "name": project.name, "description": project.description }, "stats": { "entity_count": len(entities), "relation_count": len(relations), "transcript_count": len(transcripts), "glossary_count": len(glossary) }, "entities": [ { "id": e.id, "name": e.name, "type": e.type, "definition": e.definition, "aliases": e.aliases, "mention_count": entity_stats.get(e.id, {}).get("mention_count", 0), "appears_in": entity_stats.get(e.id, {}).get("transcript_ids", []), "attributes": entity_attributes.get(e.id, []) # Phase 5: 包含属性 } for e in entities ], "relations": [ { "id": r["id"], "source_id": r["source_entity_id"], "source_name": entity_map.get(r["source_entity_id"], "Unknown"), "target_id": r["target_entity_id"], "target_name": entity_map.get(r["target_entity_id"], "Unknown"), "type": r["relation_type"], "evidence": r["evidence"] } for r in relations ], "glossary": [ { "id": g["id"], "term": g["term"], "pronunciation": g["pronunciation"], "frequency": g["frequency"] } for g in glossary ], "transcripts": [ { "id": t["id"], "filename": t["filename"], "type": t.get("type", "audio"), "created_at": t["created_at"] } for t in transcripts ] } # Phase 3: Glossary API @app.post("/api/v1/projects/{project_id}/glossary") async def add_glossary_term(project_id: str, term: GlossaryTermCreate, _=Depends(verify_api_key)): """添加术语到项目术语表""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") term_id = db.add_glossary_term( project_id=project_id, term=term.term, pronunciation=term.pronunciation ) return { "id": term_id, "term": term.term, "pronunciation": term.pronunciation, "success": True } @app.get("/api/v1/projects/{project_id}/glossary") async def get_glossary(project_id: str, _=Depends(verify_api_key)): """获取项目术语表""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() glossary = db.list_glossary(project_id) return glossary @app.delete("/api/v1/glossary/{term_id}") async def delete_glossary_term(term_id: str, _=Depends(verify_api_key)): """删除术语""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() db.delete_glossary_term(term_id) return {"success": True} # Phase 3: Entity Alignment API @app.post("/api/v1/projects/{project_id}/align-entities") async def align_project_entities(project_id: str, threshold: float = 0.85, _=Depends(verify_api_key)): """运行实体对齐算法，合并相似实体""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") aligner = get_aligner() if not aligner: raise HTTPException(status_code=500, detail="Entity aligner not available") db = get_db_manager() entities = db.list_project_entities(project_id) merged_count = 0 merged_pairs = [] # 使用 embedding 对齐 for i, entity in enumerate(entities): # 跳过已合并的实体 existing = db.get_entity(entity.id) if not existing: continue similar = aligner.find_similar_entity( project_id, entity.name, entity.definition, exclude_id=entity.id, threshold=threshold ) if similar: # 合并实体 db.merge_entities(similar.id, entity.id) merged_count += 1 merged_pairs.append({ "source": entity.name, "target": similar.name }) return { "success": True, "merged_count": merged_count, "merged_pairs": merged_pairs } @app.get("/api/v1/projects/{project_id}/entities") async def get_project_entities(project_id: str, _=Depends(verify_api_key)): """获取项目的全局实体列表""" if not DB_AVAILABLE: return [] db = get_db_manager() entities = db.list_project_entities(project_id) return [{"id": e.id, "name": e.name, "type": e.type, "definition": e.definition, "aliases": e.aliases} for e in entities] @app.get("/api/v1/projects/{project_id}/relations") async def get_project_relations(project_id: str, _=Depends(verify_api_key)): """获取项目的实体关系列表""" if not DB_AVAILABLE: return [] db = get_db_manager() relations = db.list_project_relations(project_id) # 获取实体名称映射 entities = db.list_project_entities(project_id) entity_map = {e.id: e.name for e in entities} return [{ "id": r["id"], "source_id": r["source_entity_id"], "source_name": entity_map.get(r["source_entity_id"], "Unknown"), "target_id": r["target_entity_id"], "target_name": entity_map.get(r["target_entity_id"], "Unknown"), "type": r["relation_type"], "evidence": r["evidence"] } for r in relations] @app.get("/api/v1/projects/{project_id}/transcripts") async def get_project_transcripts(project_id: str, _=Depends(verify_api_key)): """获取项目的转录列表""" if not DB_AVAILABLE: return [] db = get_db_manager() transcripts = db.list_project_transcripts(project_id) return [{ "id": t["id"], "filename": t["filename"], "type": t.get("type", "audio"), "created_at": t["created_at"], "preview": t["full_text"][:100] + "..." if len(t["full_text"]) > 100 else t["full_text"] } for t in transcripts] @app.get("/api/v1/entities/{entity_id}/mentions") async def get_entity_mentions(entity_id: str, _=Depends(verify_api_key)): """获取实体的所有提及位置""" if not DB_AVAILABLE: return [] db = get_db_manager() mentions = db.get_entity_mentions(entity_id) return [{ "id": m.id, "transcript_id": m.transcript_id, "start_pos": m.start_pos, "end_pos": m.end_pos, "text_snippet": m.text_snippet, "confidence": m.confidence } for m in mentions] # Health check @app.get("/health") async def health_check(): return { "status": "ok", "version": "0.7.0", "phase": "Phase 7 - Plugin & Integration", "oss_available": OSS_AVAILABLE, "tingwu_available": TINGWU_AVAILABLE, "db_available": DB_AVAILABLE, "doc_processor_available": DOC_PROCESSOR_AVAILABLE, "aligner_available": ALIGNER_AVAILABLE, "llm_client_available": LLM_CLIENT_AVAILABLE, "reasoner_available": REASONER_AVAILABLE, "multimodal_available": MULTIMODAL_AVAILABLE, "image_processor_available": IMAGE_PROCESSOR_AVAILABLE, "multimodal_linker_available": MULTIMODAL_LINKER_AVAILABLE, "plugin_manager_available": PLUGIN_MANAGER_AVAILABLE } # ==================== Phase 4: Agent 助手 API ==================== @app.post("/api/v1/projects/{project_id}/agent/query") async def agent_query(project_id: str, query: AgentQuery, _=Depends(verify_api_key)): """Agent RAG 问答""" if not DB_AVAILABLE or not LLM_CLIENT_AVAILABLE: raise HTTPException(status_code=500, detail="Service not available") db = get_db_manager() llm = get_llm_client() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") # 获取项目上下文 project_context = db.get_project_summary(project_id) # 构建上下文 context_parts = [] for t in project_context.get('recent_transcripts', []): context_parts.append(f"【{t['filename']}】\n{t['full_text'][:1000]}") context = "\n\n".join(context_parts) if query.stream: from fastapi.responses import StreamingResponse import json async def stream_response(): messages = [ ChatMessage(role="system", content="你是一个专业的项目分析助手，擅长从会议记录中提取洞察。"), ChatMessage(role="user", content=f"""基于以下项目信息回答问题： ## 项目信息 {json.dumps(project_context, ensure_ascii=False, indent=2)} ## 相关上下文 {context[:4000]} ## 用户问题 {query.query} 请用中文回答，保持简洁专业。如果信息不足，请明确说明。""") ] async for chunk in llm.chat_stream(messages): yield f"data: {json.dumps({'content': chunk})}\n\n" yield "data: [DONE]\n\n" return StreamingResponse(stream_response(), media_type="text/event-stream") else: answer = await llm.rag_query(query.query, context, project_context) return {"answer": answer, "project_id": project_id} @app.post("/api/v1/projects/{project_id}/agent/command") async def agent_command(project_id: str, command: AgentCommand, _=Depends(verify_api_key)): """Agent 指令执行 - 解析并执行自然语言指令""" if not DB_AVAILABLE or not LLM_CLIENT_AVAILABLE: raise HTTPException(status_code=500, detail="Service not available") db = get_db_manager() llm = get_llm_client() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") # 获取项目上下文 project_context = db.get_project_summary(project_id) # 解析指令 parsed = await llm.agent_command(command.command, project_context) intent = parsed.get("intent", "unknown") params = parsed.get("params", {}) result = {"intent": intent, "explanation": parsed.get("explanation", "")} # 执行指令 if intent == "merge_entities": # 合并实体 source_names = params.get("source_names", []) target_name = params.get("target_name", "") target_entity = None source_entities = [] # 查找目标实体 for e in project_context.get("top_entities", []): if e["name"] == target_name or target_name in e["name"]: target_entity = db.get_entity_by_name(project_id, e["name"]) break # 查找源实体 for name in source_names: for e in project_context.get("top_entities", []): if e["name"] == name or name in e["name"]: ent = db.get_entity_by_name(project_id, e["name"]) if ent and (not target_entity or ent.id != target_entity.id): source_entities.append(ent) break merged = [] if target_entity: for source in source_entities: try: db.merge_entities(target_entity.id, source.id) merged.append(source.name) except Exception as e: print(f"Merge failed: {e}") result["action"] = "merge_entities" result["target"] = target_entity.name if target_entity else None result["merged"] = merged result["success"] = len(merged) > 0 elif intent == "answer_question": # 问答 - 调用 RAG answer = await llm.rag_query(params.get("question", command.command), "", project_context) result["action"] = "answer" result["answer"] = answer elif intent == "edit_entity": # 编辑实体 entity_name = params.get("entity_name", "") field = params.get("field", "") value = params.get("value", "") entity = db.get_entity_by_name(project_id, entity_name) if entity: updated = db.update_entity(entity.id, **{field: value}) result["action"] = "edit_entity" result["entity"] = {"id": updated.id, "name": updated.name} if updated else None result["success"] = updated is not None else: result["success"] = False result["error"] = "Entity not found" else: result["action"] = "none" result["message"] = "无法理解的指令，请尝试：\n- 合并实体：把所有'客户端'合并到'App'\n- 提问：张总对项目的态度如何？\n- 编辑：修改'K8s'的定义为..." return result @app.get("/api/v1/projects/{project_id}/agent/suggest") async def agent_suggest(project_id: str, _=Depends(verify_api_key)): """获取 Agent 建议 - 基于项目数据提供洞察""" if not DB_AVAILABLE or not LLM_CLIENT_AVAILABLE: raise HTTPException(status_code=500, detail="Service not available") db = get_db_manager() llm = get_llm_client() project_context = db.get_project_summary(project_id) # 生成建议 prompt = f"""基于以下项目数据，提供3-5条分析建议： {json.dumps(project_context, ensure_ascii=False, indent=2)} 请提供： 1. 数据洞察发现 2. 建议的操作（如合并相似实体、补充定义等） 3. 值得关注的关键信息 返回 JSON 格式：{{"suggestions": [{{"type": "insight|action", "title": "...", "description": "..."}}]}}""" messages = [ChatMessage(role="user", content=prompt)] content = await llm.chat(messages, temperature=0.3) import re json_match = re.search(r'\{{.*?\}}', content, re.DOTALL) if json_match: try: data = json.loads(json_match.group()) return data except: pass return {"suggestions": []} # ==================== Phase 4: 知识溯源 API ==================== @app.get("/api/v1/relations/{relation_id}/provenance") async def get_relation_provenance(relation_id: str, _=Depends(verify_api_key)): """获取关系的知识溯源信息""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() relation = db.get_relation_with_details(relation_id) if not relation: raise HTTPException(status_code=404, detail="Relation not found") return { "relation_id": relation_id, "source": relation.get("source_name"), "target": relation.get("target_name"), "type": relation.get("relation_type"), "evidence": relation.get("evidence"), "transcript": { "id": relation.get("transcript_id"), "filename": relation.get("transcript_filename"), } if relation.get("transcript_id") else None } @app.get("/api/v1/entities/{entity_id}/details") async def get_entity_details(entity_id: str, _=Depends(verify_api_key)): """获取实体详情，包含所有提及位置""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() entity = db.get_entity_with_mentions(entity_id) if not entity: raise HTTPException(status_code=404, detail="Entity not found") return entity @app.get("/api/v1/entities/{entity_id}/evolution") async def get_entity_evolution(entity_id: str, _=Depends(verify_api_key)): """分析实体的演变和态度变化""" if not DB_AVAILABLE or not LLM_CLIENT_AVAILABLE: raise HTTPException(status_code=500, detail="Service not available") db = get_db_manager() llm = get_llm_client() entity = db.get_entity_with_mentions(entity_id) if not entity: raise HTTPException(status_code=404, detail="Entity not found") # 分析演变 analysis = await llm.analyze_entity_evolution(entity["name"], entity.get("mentions", [])) return { "entity_id": entity_id, "entity_name": entity["name"], "mention_count": entity.get("mention_count", 0), "analysis": analysis, "timeline": [ { "date": m.get("transcript_date"), "snippet": m.get("text_snippet"), "transcript_id": m.get("transcript_id"), "filename": m.get("filename") } for m in entity.get("mentions", []) ] } # ==================== Phase 4: 实体管理增强 API ==================== @app.get("/api/v1/projects/{project_id}/entities/search") async def search_entities(project_id: str, q: str, _=Depends(verify_api_key)): """搜索实体""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() entities = db.search_entities(project_id, q) return [{"id": e.id, "name": e.name, "type": e.type, "definition": e.definition} for e in entities] # ==================== Phase 5: 时间线视图 API ==================== @app.get("/api/v1/projects/{project_id}/timeline") async def get_project_timeline( project_id: str, entity_id: str = None, start_date: str = None, end_date: str = None, _=Depends(verify_api_key) ): """获取项目时间线 - 按时间顺序的实体提及和关系事件""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") timeline = db.get_project_timeline(project_id, entity_id, start_date, end_date) return { "project_id": project_id, "events": timeline, "total_count": len(timeline) } @app.get("/api/v1/projects/{project_id}/timeline/summary") async def get_timeline_summary(project_id: str, _=Depends(verify_api_key)): """获取项目时间线摘要统计""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") summary = db.get_entity_timeline_summary(project_id) return { "project_id": project_id, "project_name": project.name, **summary } @app.get("/api/v1/entities/{entity_id}/timeline") async def get_entity_timeline(entity_id: str, _=Depends(verify_api_key)): """获取单个实体的时间线""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() entity = db.get_entity(entity_id) if not entity: raise HTTPException(status_code=404, detail="Entity not found") timeline = db.get_project_timeline(entity.project_id, entity_id) return { "entity_id": entity_id, "entity_name": entity.name, "entity_type": entity.type, "events": timeline, "total_count": len(timeline) } # ==================== Phase 5: 知识推理与问答增强 API ==================== class ReasoningQuery(BaseModel): query: str reasoning_depth: str = "medium" # shallow/medium/deep stream: bool = False @app.post("/api/v1/projects/{project_id}/reasoning/query") async def reasoning_query(project_id: str, query: ReasoningQuery, _=Depends(verify_api_key)): """ 增强问答 - 基于知识推理的智能问答 支持多种推理类型： - 因果推理：分析原因和影响 - 对比推理：比较实体间的异同 - 时序推理：分析时间线和演变 - 关联推理：发现隐含关联 """ if not DB_AVAILABLE or not REASONER_AVAILABLE: raise HTTPException(status_code=500, detail="Knowledge reasoner not available") db = get_db_manager() reasoner = get_knowledge_reasoner() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") # 获取项目上下文 project_context = db.get_project_summary(project_id) # 获取知识图谱数据 entities = db.list_project_entities(project_id) relations = db.list_project_relations(project_id) graph_data = { "entities": [{"id": e.id, "name": e.name, "type": e.type, "definition": e.definition} for e in entities], "relations": relations } # 执行增强问答 result = await reasoner.enhanced_qa( query=query.query, project_context=project_context, graph_data=graph_data, reasoning_depth=query.reasoning_depth ) return { "answer": result.answer, "reasoning_type": result.reasoning_type.value, "confidence": result.confidence, "evidence": result.evidence, "knowledge_gaps": result.gaps, "project_id": project_id } @app.post("/api/v1/projects/{project_id}/reasoning/inference-path") async def find_inference_path( project_id: str, start_entity: str, end_entity: str, _=Depends(verify_api_key) ): """ 发现两个实体之间的推理路径 在知识图谱中搜索从 start_entity 到 end_entity 的路径 """ if not DB_AVAILABLE or not REASONER_AVAILABLE: raise HTTPException(status_code=500, detail="Knowledge reasoner not available") db = get_db_manager() reasoner = get_knowledge_reasoner() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") # 获取知识图谱数据 entities = db.list_project_entities(project_id) relations = db.list_project_relations(project_id) graph_data = { "entities": [{"id": e.id, "name": e.name, "type": e.type} for e in entities], "relations": relations } # 查找推理路径 paths = reasoner.find_inference_paths(start_entity, end_entity, graph_data) return { "start_entity": start_entity, "end_entity": end_entity, "paths": [ { "path": path.path, "strength": path.strength, "path_description": " -> ".join([p["entity"] for p in path.path]) } for path in paths[:5] # 最多返回5条路径 ], "total_paths": len(paths) } class SummaryRequest(BaseModel): summary_type: str = "comprehensive" # comprehensive/executive/technical/risk @app.post("/api/v1/projects/{project_id}/reasoning/summary") async def project_summary(project_id: str, req: SummaryRequest, _=Depends(verify_api_key)): """ 项目智能总结 根据类型生成不同侧重点的总结： - comprehensive: 全面总结 - executive: 高管摘要 - technical: 技术总结 - risk: 风险分析 """ if not DB_AVAILABLE or not REASONER_AVAILABLE: raise HTTPException(status_code=500, detail="Knowledge reasoner not available") db = get_db_manager() reasoner = get_knowledge_reasoner() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") # 获取项目上下文 project_context = db.get_project_summary(project_id) # 获取知识图谱数据 entities = db.list_project_entities(project_id) relations = db.list_project_relations(project_id) graph_data = { "entities": [{"id": e.id, "name": e.name, "type": e.type} for e in entities], "relations": relations } # 生成总结 summary = await reasoner.summarize_project( project_context=project_context, graph_data=graph_data, summary_type=req.summary_type ) return { "project_id": project_id, "summary_type": req.summary_type, **summary **summary } # ==================== Phase 5: 实体属性扩展 API ==================== class AttributeTemplateCreate(BaseModel): name: str type: str # text, number, date, select, multiselect, boolean options: Optional[List[str]] = None default_value: Optional[str] = "" description: Optional[str] = "" is_required: bool = False sort_order: int = 0 class AttributeTemplateUpdate(BaseModel): name: Optional[str] = None type: Optional[str] = None options: Optional[List[str]] = None default_value: Optional[str] = None description: Optional[str] = None is_required: Optional[bool] = None sort_order: Optional[int] = None class EntityAttributeSet(BaseModel): name: str type: str value: Optional[Union[str, int, float, List[str]]] = None template_id: Optional[str] = None options: Optional[List[str]] = None change_reason: Optional[str] = "" class EntityAttributeBatchSet(BaseModel): attributes: List[EntityAttributeSet] change_reason: Optional[str] = "" # 属性模板管理 API @app.post("/api/v1/projects/{project_id}/attribute-templates") async def create_attribute_template_endpoint(project_id: str, template: AttributeTemplateCreate, _=Depends(verify_api_key)): """创建属性模板""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") from db_manager import AttributeTemplate db = get_db_manager() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") new_template = AttributeTemplate( id=str(uuid.uuid4())[:8], project_id=project_id, name=template.name, type=template.type, options=template.options or [], default_value=template.default_value or "", description=template.description or "", is_required=template.is_required, sort_order=template.sort_order ) db.create_attribute_template(new_template) return { "id": new_template.id, "name": new_template.name, "type": new_template.type, "success": True } @app.get("/api/v1/projects/{project_id}/attribute-templates") async def list_attribute_templates_endpoint(project_id: str, _=Depends(verify_api_key)): """列出项目的所有属性模板""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() templates = db.list_attribute_templates(project_id) return [ { "id": t.id, "name": t.name, "type": t.type, "options": t.options, "default_value": t.default_value, "description": t.description, "is_required": t.is_required, "sort_order": t.sort_order } for t in templates ] @app.get("/api/v1/attribute-templates/{template_id}") async def get_attribute_template_endpoint(template_id: str, _=Depends(verify_api_key)): """获取属性模板详情""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() template = db.get_attribute_template(template_id) if not template: raise HTTPException(status_code=404, detail="Template not found") return { "id": template.id, "name": template.name, "type": template.type, "options": template.options, "default_value": template.default_value, "description": template.description, "is_required": template.is_required, "sort_order": template.sort_order } @app.put("/api/v1/attribute-templates/{template_id}") async def update_attribute_template_endpoint(template_id: str, update: AttributeTemplateUpdate, _=Depends(verify_api_key)): """更新属性模板""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() template = db.get_attribute_template(template_id) if not template: raise HTTPException(status_code=404, detail="Template not found") update_data = {k: v for k, v in update.dict().items() if v is not None} updated = db.update_attribute_template(template_id, **update_data) return { "id": updated.id, "name": updated.name, "type": updated.type, "success": True } @app.delete("/api/v1/attribute-templates/{template_id}") async def delete_attribute_template_endpoint(template_id: str, _=Depends(verify_api_key)): """删除属性模板""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() db.delete_attribute_template(template_id) return {"success": True, "message": f"Template {template_id} deleted"} # 实体属性值管理 API @app.post("/api/v1/entities/{entity_id}/attributes") async def set_entity_attribute_endpoint(entity_id: str, attr: EntityAttributeSet, _=Depends(verify_api_key)): """设置实体属性值""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() entity = db.get_entity(entity_id) if not entity: raise HTTPException(status_code=404, detail="Entity not found") # 验证类型 valid_types = ['text', 'number', 'date', 'select', 'multiselect'] if attr.type not in valid_types: raise HTTPException(status_code=400, detail=f"Invalid type. Must be one of: {valid_types}") # 处理 value value = attr.value if attr.type == 'multiselect' and isinstance(value, list): value = json.dumps(value) elif value is not None: value = str(value) # 处理 options options = attr.options if options: options = json.dumps(options) # 检查是否已存在 conn = db.get_conn() existing = conn.execute( "SELECT * FROM entity_attributes WHERE entity_id = ? AND name = ?", (entity_id, attr.name) ).fetchone() now = datetime.now().isoformat() if existing: # 记录历史 conn.execute( """INSERT INTO attribute_history (id, entity_id, attribute_name, old_value, new_value, changed_by, changed_at, change_reason) VALUES (?, ?, ?, ?, ?, ?, ?, ?)""", (str(uuid.uuid4())[:8], entity_id, attr.name, existing['value'], value, "user", now, attr.change_reason or "") ) # 更新 conn.execute( """UPDATE entity_attributes SET value = ?, type = ?, options = ?, updated_at = ? WHERE id = ?""", (value, attr.type, options, now, existing['id']) ) attr_id = existing['id'] else: # 创建 attr_id = str(uuid.uuid4())[:8] conn.execute( """INSERT INTO entity_attributes (id, entity_id, template_id, name, type, value, options, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)""", (attr_id, entity_id, attr.template_id, attr.name, attr.type, value, options, now, now) ) # 记录历史 conn.execute( """INSERT INTO attribute_history (id, entity_id, attribute_name, old_value, new_value, changed_by, changed_at, change_reason) VALUES (?, ?, ?, ?, ?, ?, ?, ?)""", (str(uuid.uuid4())[:8], entity_id, attr.name, None, value, "user", now, attr.change_reason or "创建属性") ) conn.commit() conn.close() return { "id": attr_id, "entity_id": entity_id, "name": attr.name, "type": attr.type, "value": attr.value, "success": True } @app.post("/api/v1/entities/{entity_id}/attributes/batch") async def batch_set_entity_attributes_endpoint(entity_id: str, batch: EntityAttributeBatchSet, _=Depends(verify_api_key)): """批量设置实体属性值""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") from db_manager import EntityAttribute db = get_db_manager() entity = db.get_entity(entity_id) if not entity: raise HTTPException(status_code=404, detail="Entity not found") results = [] for attr_data in batch.attributes: template = db.get_attribute_template(attr_data.template_id) if template: new_attr = EntityAttribute( id=str(uuid.uuid4())[:8], entity_id=entity_id, template_id=attr_data.template_id, value=attr_data.value ) db.set_entity_attribute(new_attr, changed_by="user", change_reason=batch.change_reason or "批量更新") results.append({ "template_id": attr_data.template_id, "template_name": template.name, "value": attr_data.value }) return { "entity_id": entity_id, "updated_count": len(results), "attributes": results, "success": True } @app.get("/api/v1/entities/{entity_id}/attributes") async def get_entity_attributes_endpoint(entity_id: str, _=Depends(verify_api_key)): """获取实体的所有属性值""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() entity = db.get_entity(entity_id) if not entity: raise HTTPException(status_code=404, detail="Entity not found") attrs = db.get_entity_attributes(entity_id) return [ { "id": a.id, "template_id": a.template_id, "template_name": a.template_name, "template_type": a.template_type, "value": a.value } for a in attrs ] @app.delete("/api/v1/entities/{entity_id}/attributes/{template_id}") async def delete_entity_attribute_endpoint(entity_id: str, template_id: str, reason: Optional[str] = "", _=Depends(verify_api_key)): """删除实体属性值""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() db.delete_entity_attribute(entity_id, template_id, changed_by="user", change_reason=reason) return {"success": True, "message": "Attribute deleted"} # 属性历史 API @app.get("/api/v1/entities/{entity_id}/attributes/history") async def get_entity_attribute_history_endpoint(entity_id: str, limit: int = 50, _=Depends(verify_api_key)): """获取实体的属性变更历史""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() history = db.get_attribute_history(entity_id=entity_id, limit=limit) return [ { "id": h.id, "attribute_name": h.attribute_name, "old_value": h.old_value, "new_value": h.new_value, "changed_by": h.changed_by, "changed_at": h.changed_at, "change_reason": h.change_reason } for h in history ] @app.get("/api/v1/attribute-templates/{template_id}/history") async def get_template_history_endpoint(template_id: str, limit: int = 50, _=Depends(verify_api_key)): """获取属性模板的所有变更历史（跨实体）""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() history = db.get_attribute_history(template_id=template_id, limit=limit) return [ { "id": h.id, "entity_id": h.entity_id, "template_name": h.template_name, "old_value": h.old_value, "new_value": h.new_value, "changed_by": h.changed_by, "changed_at": h.changed_at, "change_reason": h.change_reason } for h in history ] # 属性筛选搜索 API @app.get("/api/v1/projects/{project_id}/entities/search-by-attributes") async def search_entities_by_attributes_endpoint( project_id: str, attribute_filter: Optional[str] = None, # JSON 格式: {"职位": "经理", "部门": "技术部"} _=Depends(verify_api_key) ): """根据属性筛选搜索实体""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") filters = {} if attribute_filter: try: filters = json.loads(attribute_filter) except json.JSONDecodeError: raise HTTPException(status_code=400, detail="Invalid attribute_filter JSON") entities = db.search_entities_by_attributes(project_id, filters) return [ { "id": e.id, "name": e.name, "type": e.type, "definition": e.definition, "attributes": e.attributes } for e in entities ] # ==================== 导出功能 API ==================== from fastapi.responses import StreamingResponse, FileResponse @app.get("/api/v1/projects/{project_id}/export/graph-svg") async def export_graph_svg_endpoint(project_id: str, _=Depends(verify_api_key)): """导出知识图谱为 SVG""" if not DB_AVAILABLE or not EXPORT_AVAILABLE: raise HTTPException(status_code=500, detail="Export functionality not available") db = get_db_manager() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") # 获取项目数据 entities_data = db.get_project_entities(project_id) relations_data = db.get_project_relations(project_id) # 转换为导出格式 entities = [] for e in entities_data: attrs = db.get_entity_attributes(e.id) entities.append(ExportEntity( id=e.id, name=e.name, type=e.type, definition=e.definition or "", aliases=json.loads(e.aliases) if e.aliases else [], mention_count=e.mention_count, attributes={a.template_name: a.value for a in attrs} )) relations = [] for r in relations_data: relations.append(ExportRelation( id=r.id, source=r.source_name, target=r.target_name, relation_type=r.relation_type, confidence=r.confidence, evidence=r.evidence or "" )) export_mgr = get_export_manager() svg_content = export_mgr.export_knowledge_graph_svg(project_id, entities, relations) return StreamingResponse( io.BytesIO(svg_content.encode('utf-8')), media_type="image/svg+xml", headers={"Content-Disposition": f"attachment; filename=insightflow-graph-{project_id}.svg"} ) @app.get("/api/v1/projects/{project_id}/export/graph-png") async def export_graph_png_endpoint(project_id: str, _=Depends(verify_api_key)): """导出知识图谱为 PNG""" if not DB_AVAILABLE or not EXPORT_AVAILABLE: raise HTTPException(status_code=500, detail="Export functionality not available") db = get_db_manager() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") # 获取项目数据 entities_data = db.get_project_entities(project_id) relations_data = db.get_project_relations(project_id) # 转换为导出格式 entities = [] for e in entities_data: attrs = db.get_entity_attributes(e.id) entities.append(ExportEntity( id=e.id, name=e.name, type=e.type, definition=e.definition or "", aliases=json.loads(e.aliases) if e.aliases else [], mention_count=e.mention_count, attributes={a.template_name: a.value for a in attrs} )) relations = [] for r in relations_data: relations.append(ExportRelation( id=r.id, source=r.source_name, target=r.target_name, relation_type=r.relation_type, confidence=r.confidence, evidence=r.evidence or "" )) export_mgr = get_export_manager() png_bytes = export_mgr.export_knowledge_graph_png(project_id, entities, relations) return StreamingResponse( io.BytesIO(png_bytes), media_type="image/png", headers={"Content-Disposition": f"attachment; filename=insightflow-graph-{project_id}.png"} ) @app.get("/api/v1/projects/{project_id}/export/entities-excel") async def export_entities_excel_endpoint(project_id: str, _=Depends(verify_api_key)): """导出实体数据为 Excel""" if not DB_AVAILABLE or not EXPORT_AVAILABLE: raise HTTPException(status_code=500, detail="Export functionality not available") db = get_db_manager() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") # 获取实体数据 entities_data = db.get_project_entities(project_id) entities = [] for e in entities_data: attrs = db.get_entity_attributes(e.id) entities.append(ExportEntity( id=e.id, name=e.name, type=e.type, definition=e.definition or "", aliases=json.loads(e.aliases) if e.aliases else [], mention_count=e.mention_count, attributes={a.template_name: a.value for a in attrs} )) export_mgr = get_export_manager() excel_bytes = export_mgr.export_entities_excel(entities) return StreamingResponse( io.BytesIO(excel_bytes), media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", headers={"Content-Disposition": f"attachment; filename=insightflow-entities-{project_id}.xlsx"} ) @app.get("/api/v1/projects/{project_id}/export/entities-csv") async def export_entities_csv_endpoint(project_id: str, _=Depends(verify_api_key)): """导出实体数据为 CSV""" if not DB_AVAILABLE or not EXPORT_AVAILABLE: raise HTTPException(status_code=500, detail="Export functionality not available") db = get_db_manager() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") # 获取实体数据 entities_data = db.get_project_entities(project_id) entities = [] for e in entities_data: attrs = db.get_entity_attributes(e.id) entities.append(ExportEntity( id=e.id, name=e.name, type=e.type, definition=e.definition or "", aliases=json.loads(e.aliases) if e.aliases else [], mention_count=e.mention_count, attributes={a.template_name: a.value for a in attrs} )) export_mgr = get_export_manager() csv_content = export_mgr.export_entities_csv(entities) return StreamingResponse( io.BytesIO(csv_content.encode('utf-8')), media_type="text/csv", headers={"Content-Disposition": f"attachment; filename=insightflow-entities-{project_id}.csv"} ) @app.get("/api/v1/projects/{project_id}/export/relations-csv") async def export_relations_csv_endpoint(project_id: str, _=Depends(verify_api_key)): """导出关系数据为 CSV""" if not DB_AVAILABLE or not EXPORT_AVAILABLE: raise HTTPException(status_code=500, detail="Export functionality not available") db = get_db_manager() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") # 获取关系数据 relations_data = db.get_project_relations(project_id) relations = [] for r in relations_data: relations.append(ExportRelation( id=r.id, source=r.source_name, target=r.target_name, relation_type=r.relation_type, confidence=r.confidence, evidence=r.evidence or "" )) export_mgr = get_export_manager() csv_content = export_mgr.export_relations_csv(relations) return StreamingResponse( io.BytesIO(csv_content.encode('utf-8')), media_type="text/csv", headers={"Content-Disposition": f"attachment; filename=insightflow-relations-{project_id}.csv"} ) @app.get("/api/v1/projects/{project_id}/export/report-pdf") async def export_report_pdf_endpoint(project_id: str, _=Depends(verify_api_key)): """导出项目报告为 PDF""" if not DB_AVAILABLE or not EXPORT_AVAILABLE: raise HTTPException(status_code=500, detail="Export functionality not available") db = get_db_manager() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") # 获取项目数据 entities_data = db.get_project_entities(project_id) relations_data = db.get_project_relations(project_id) transcripts_data = db.get_project_transcripts(project_id) # 转换为导出格式 entities = [] for e in entities_data: attrs = db.get_entity_attributes(e.id) entities.append(ExportEntity( id=e.id, name=e.name, type=e.type, definition=e.definition or "", aliases=json.loads(e.aliases) if e.aliases else [], mention_count=e.mention_count, attributes={a.template_name: a.value for a in attrs} )) relations = [] for r in relations_data: relations.append(ExportRelation( id=r.id, source=r.source_name, target=r.target_name, relation_type=r.relation_type, confidence=r.confidence, evidence=r.evidence or "" )) transcripts = [] for t in transcripts_data: segments = json.loads(t.segments) if t.segments else [] transcripts.append(ExportTranscript( id=t.id, name=t.name, type=t.type, content=t.full_text or "", segments=segments, entity_mentions=[] )) # 获取项目总结 summary = "" if REASONER_AVAILABLE: try: reasoner = get_knowledge_reasoner() summary_result = reasoner.generate_project_summary(project_id, db) summary = summary_result.get("summary", "") except: pass export_mgr = get_export_manager() pdf_bytes = export_mgr.export_project_report_pdf( project_id, project.name, entities, relations, transcripts, summary ) return StreamingResponse( io.BytesIO(pdf_bytes), media_type="application/pdf", headers={"Content-Disposition": f"attachment; filename=insightflow-report-{project_id}.pdf"} ) @app.get("/api/v1/projects/{project_id}/export/project-json") async def export_project_json_endpoint(project_id: str, _=Depends(verify_api_key)): """导出完整项目数据为 JSON""" if not DB_AVAILABLE or not EXPORT_AVAILABLE: raise HTTPException(status_code=500, detail="Export functionality not available") db = get_db_manager() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") # 获取项目数据 entities_data = db.get_project_entities(project_id) relations_data = db.get_project_relations(project_id) transcripts_data = db.get_project_transcripts(project_id) # 转换为导出格式 entities = [] for e in entities_data: attrs = db.get_entity_attributes(e.id) entities.append(ExportEntity( id=e.id, name=e.name, type=e.type, definition=e.definition or "", aliases=json.loads(e.aliases) if e.aliases else [], mention_count=e.mention_count, attributes={a.template_name: a.value for a in attrs} )) relations = [] for r in relations_data: relations.append(ExportRelation( id=r.id, source=r.source_name, target=r.target_name, relation_type=r.relation_type, confidence=r.confidence, evidence=r.evidence or "" )) transcripts = [] for t in transcripts_data: segments = json.loads(t.segments) if t.segments else [] transcripts.append(ExportTranscript( id=t.id, name=t.name, type=t.type, content=t.full_text or "", segments=segments, entity_mentions=[] )) export_mgr = get_export_manager() json_content = export_mgr.export_project_json( project_id, project.name, entities, relations, transcripts ) return StreamingResponse( io.BytesIO(json_content.encode('utf-8')), media_type="application/json", headers={"Content-Disposition": f"attachment; filename=insightflow-project-{project_id}.json"} ) @app.get("/api/v1/transcripts/{transcript_id}/export/markdown") async def export_transcript_markdown_endpoint(transcript_id: str, _=Depends(verify_api_key)): """导出转录文本为 Markdown""" if not DB_AVAILABLE or not EXPORT_AVAILABLE: raise HTTPException(status_code=500, detail="Export functionality not available") db = get_db_manager() transcript = db.get_transcript(transcript_id) if not transcript: raise HTTPException(status_code=404, detail="Transcript not found") # 获取实体提及 mentions = db.get_transcript_entity_mentions(transcript_id) # 获取项目实体用于映射 entities_data = db.get_project_entities(transcript.project_id) entities_map = {e.id: ExportEntity( id=e.id, name=e.name, type=e.type, definition=e.definition or "", aliases=json.loads(e.aliases) if e.aliases else [], mention_count=e.mention_count, attributes={} ) for e in entities_data} segments = json.loads(transcript.segments) if transcript.segments else [] export_transcript = ExportTranscript( id=transcript.id, name=transcript.name, type=transcript.type, content=transcript.full_text or "", segments=segments, entity_mentions=[{ "entity_id": m.entity_id, "entity_name": m.entity_name, "position": m.position, "context": m.context } for m in mentions] ) export_mgr = get_export_manager() markdown_content = export_mgr.export_transcript_markdown(export_transcript, entities_map) return StreamingResponse( io.BytesIO(markdown_content.encode('utf-8')), media_type="text/markdown", headers={"Content-Disposition": f"attachment; filename=insightflow-transcript-{transcript_id}.md"} ) # ==================== Neo4j Graph Database API ==================== class Neo4jSyncRequest(BaseModel): project_id: str class PathQueryRequest(BaseModel): source_entity_id: str target_entity_id: str max_depth: int = 10 class GraphQueryRequest(BaseModel): entity_ids: List[str] depth: int = 1 @app.get("/api/v1/neo4j/status") async def neo4j_status(_=Depends(verify_api_key)): """获取 Neo4j 连接状态""" if not NEO4J_AVAILABLE: return { "available": False, "connected": False, "message": "Neo4j driver not installed" } try: manager = get_neo4j_manager() connected = manager.is_connected() return { "available": True, "connected": connected, "uri": manager.uri if connected else None, "message": "Connected" if connected else "Not connected" } except Exception as e: return { "available": True, "connected": False, "message": str(e) } @app.post("/api/v1/neo4j/sync") async def neo4j_sync_project(request: Neo4jSyncRequest, _=Depends(verify_api_key)): """同步项目数据到 Neo4j""" if not NEO4J_AVAILABLE: raise HTTPException(status_code=503, detail="Neo4j not available") if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") manager = get_neo4j_manager() if not manager.is_connected(): raise HTTPException(status_code=503, detail="Neo4j not connected") db = get_db_manager() project = db.get_project(request.project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") # 获取项目所有实体 entities = db.get_project_entities(request.project_id) entities_data = [] for e in entities: entities_data.append({ "id": e.id, "name": e.name, "type": e.type, "definition": e.definition, "aliases": json.loads(e.aliases) if e.aliases else [], "properties": e.attributes if hasattr(e, 'attributes') else {} }) # 获取项目所有关系 relations = db.get_project_relations(request.project_id) relations_data = [] for r in relations: relations_data.append({ "id": r.id, "source_entity_id": r.source_entity_id, "target_entity_id": r.target_entity_id, "relation_type": r.relation_type, "evidence": r.evidence, "properties": {} }) # 同步到 Neo4j sync_project_to_neo4j( project_id=request.project_id, project_name=project.name, entities=entities_data, relations=relations_data ) return { "success": True, "project_id": request.project_id, "entities_synced": len(entities_data), "relations_synced": len(relations_data), "message": f"Synced {len(entities_data)} entities and {len(relations_data)} relations to Neo4j" } @app.get("/api/v1/projects/{project_id}/graph/stats") async def get_graph_stats(project_id: str, _=Depends(verify_api_key)): """获取项目图统计信息""" if not NEO4J_AVAILABLE: raise HTTPException(status_code=503, detail="Neo4j not available") manager = get_neo4j_manager() if not manager.is_connected(): raise HTTPException(status_code=503, detail="Neo4j not connected") stats = manager.get_graph_stats(project_id) return stats @app.post("/api/v1/graph/shortest-path") async def find_shortest_path(request: PathQueryRequest, _=Depends(verify_api_key)): """查找两个实体之间的最短路径""" if not NEO4J_AVAILABLE: raise HTTPException(status_code=503, detail="Neo4j not available") manager = get_neo4j_manager() if not manager.is_connected(): raise HTTPException(status_code=503, detail="Neo4j not connected") path = manager.find_shortest_path( request.source_entity_id, request.target_entity_id, request.max_depth ) if not path: return { "found": False, "message": "No path found between entities" } return { "found": True, "path": { "nodes": path.nodes, "relationships": path.relationships, "length": path.length } } @app.post("/api/v1/graph/paths") async def find_all_paths(request: PathQueryRequest, _=Depends(verify_api_key)): """查找两个实体之间的所有路径""" if not NEO4J_AVAILABLE: raise HTTPException(status_code=503, detail="Neo4j not available") manager = get_neo4j_manager() if not manager.is_connected(): raise HTTPException(status_code=503, detail="Neo4j not connected") paths = manager.find_all_paths( request.source_entity_id, request.target_entity_id, request.max_depth ) return { "count": len(paths), "paths": [ { "nodes": p.nodes, "relationships": p.relationships, "length": p.length } for p in paths ] } @app.get("/api/v1/entities/{entity_id}/neighbors") async def get_entity_neighbors( entity_id: str, relation_type: str = None, limit: int = 50, _=Depends(verify_api_key) ): """获取实体的邻居节点""" if not NEO4J_AVAILABLE: raise HTTPException(status_code=503, detail="Neo4j not available") manager = get_neo4j_manager() if not manager.is_connected(): raise HTTPException(status_code=503, detail="Neo4j not connected") neighbors = manager.find_neighbors(entity_id, relation_type, limit) return { "entity_id": entity_id, "count": len(neighbors), "neighbors": neighbors } @app.get("/api/v1/entities/{entity_id1}/common-neighbors/{entity_id2}") async def get_common_neighbors(entity_id1: str, entity_id2: str, _=Depends(verify_api_key)): """获取两个实体的共同邻居""" if not NEO4J_AVAILABLE: raise HTTPException(status_code=503, detail="Neo4j not available") manager = get_neo4j_manager() if not manager.is_connected(): raise HTTPException(status_code=503, detail="Neo4j not connected") common = manager.find_common_neighbors(entity_id1, entity_id2) return { "entity_id1": entity_id1, "entity_id2": entity_id2, "count": len(common), "common_neighbors": common } @app.get("/api/v1/projects/{project_id}/graph/centrality") async def get_centrality_analysis( project_id: str, metric: str = "degree", _=Depends(verify_api_key) ): """获取中心性分析结果""" if not NEO4J_AVAILABLE: raise HTTPException(status_code=503, detail="Neo4j not available") manager = get_neo4j_manager() if not manager.is_connected(): raise HTTPException(status_code=503, detail="Neo4j not connected") rankings = manager.find_central_entities(project_id, metric) return { "metric": metric, "count": len(rankings), "rankings": [ { "entity_id": r.entity_id, "entity_name": r.entity_name, "score": r.score, "rank": r.rank } for r in rankings ] } @app.get("/api/v1/projects/{project_id}/graph/communities") async def get_communities(project_id: str, _=Depends(verify_api_key)): """获取社区发现结果""" if not NEO4J_AVAILABLE: raise HTTPException(status_code=503, detail="Neo4j not available") manager = get_neo4j_manager() if not manager.is_connected(): raise HTTPException(status_code=503, detail="Neo4j not connected") communities = manager.detect_communities(project_id) return { "count": len(communities), "communities": [ { "community_id": c.community_id, "size": c.size, "density": c.density, "nodes": c.nodes } for c in communities ] } @app.post("/api/v1/graph/subgraph") async def get_subgraph(request: GraphQueryRequest, _=Depends(verify_api_key)): """获取子图""" if not NEO4J_AVAILABLE: raise HTTPException(status_code=503, detail="Neo4j not available") manager = get_neo4j_manager() if not manager.is_connected(): raise HTTPException(status_code=503, detail="Neo4j not connected") subgraph = manager.get_subgraph(request.entity_ids, request.depth) return subgraph # ==================== Phase 6: API Key Management Endpoints ==================== @app.post("/api/v1/api-keys", response_model=ApiKeyCreateResponse, tags=["API Keys"]) async def create_api_key(request: ApiKeyCreate, _=Depends(verify_api_key)): """ 创建新的 API Key - **name**: API Key 的名称/描述 - **permissions**: 权限列表，可选值: read, write, delete - **rate_limit**: 每分钟请求限制，默认 60 - **expires_days**: 过期天数（可选，不设置则永不过期） """ if not API_KEY_AVAILABLE: raise HTTPException(status_code=503, detail="API Key management not available") key_manager = get_api_key_manager() raw_key, api_key = key_manager.create_key( name=request.name, permissions=request.permissions, rate_limit=request.rate_limit, expires_days=request.expires_days ) return ApiKeyCreateResponse( api_key=raw_key, info=ApiKeyResponse( id=api_key.id, key_preview=api_key.key_preview, name=api_key.name, permissions=api_key.permissions, rate_limit=api_key.rate_limit, status=api_key.status, created_at=api_key.created_at, expires_at=api_key.expires_at, last_used_at=api_key.last_used_at, total_calls=api_key.total_calls ) ) @app.get("/api/v1/api-keys", response_model=ApiKeyListResponse, tags=["API Keys"]) async def list_api_keys( status: Optional[str] = None, limit: int = 100, offset: int = 0, _=Depends(verify_api_key) ): """ 列出所有 API Keys - **status**: 按状态筛选 (active, revoked, expired) - **limit**: 返回数量限制 - **offset**: 分页偏移 """ if not API_KEY_AVAILABLE: raise HTTPException(status_code=503, detail="API Key management not available") key_manager = get_api_key_manager() keys = key_manager.list_keys(status=status, limit=limit, offset=offset) return ApiKeyListResponse( keys=[ ApiKeyResponse( id=k.id, key_preview=k.key_preview, name=k.name, permissions=k.permissions, rate_limit=k.rate_limit, status=k.status, created_at=k.created_at, expires_at=k.expires_at, last_used_at=k.last_used_at, total_calls=k.total_calls ) for k in keys ], total=len(keys) ) @app.get("/api/v1/api-keys/{key_id}", response_model=ApiKeyResponse, tags=["API Keys"]) async def get_api_key(key_id: str, _=Depends(verify_api_key)): """获取单个 API Key 详情""" if not API_KEY_AVAILABLE: raise HTTPException(status_code=503, detail="API Key management not available") key_manager = get_api_key_manager() key = key_manager.get_key_by_id(key_id) if not key: raise HTTPException(status_code=404, detail="API Key not found") return ApiKeyResponse( id=key.id, key_preview=key.key_preview, name=key.name, permissions=key.permissions, rate_limit=key.rate_limit, status=key.status, created_at=key.created_at, expires_at=key.expires_at, last_used_at=key.last_used_at, total_calls=key.total_calls ) @app.patch("/api/v1/api-keys/{key_id}", response_model=ApiKeyResponse, tags=["API Keys"]) async def update_api_key(key_id: str, request: ApiKeyUpdate, _=Depends(verify_api_key)): """ 更新 API Key 信息 可以更新的字段：name, permissions, rate_limit """ if not API_KEY_AVAILABLE: raise HTTPException(status_code=503, detail="API Key management not available") key_manager = get_api_key_manager() # 构建更新数据 updates = {} if request.name is not None: updates["name"] = request.name if request.permissions is not None: updates["permissions"] = request.permissions if request.rate_limit is not None: updates["rate_limit"] = request.rate_limit if not updates: raise HTTPException(status_code=400, detail="No fields to update") success = key_manager.update_key(key_id, **updates) if not success: raise HTTPException(status_code=404, detail="API Key not found") # 返回更新后的 key key = key_manager.get_key_by_id(key_id) return ApiKeyResponse( id=key.id, key_preview=key.key_preview, name=key.name, permissions=key.permissions, rate_limit=key.rate_limit, status=key.status, created_at=key.created_at, expires_at=key.expires_at, last_used_at=key.last_used_at, total_calls=key.total_calls ) @app.delete("/api/v1/api-keys/{key_id}", tags=["API Keys"]) async def revoke_api_key(key_id: str, reason: str = "", _=Depends(verify_api_key)): """ 撤销 API Key 撤销后的 Key 将无法再使用，但记录会保留用于审计 """ if not API_KEY_AVAILABLE: raise HTTPException(status_code=503, detail="API Key management not available") key_manager = get_api_key_manager() success = key_manager.revoke_key(key_id, reason=reason) if not success: raise HTTPException(status_code=404, detail="API Key not found or already revoked") return {"success": True, "message": f"API Key {key_id} revoked"} @app.get("/api/v1/api-keys/{key_id}/stats", response_model=ApiStatsResponse, tags=["API Keys"]) async def get_api_key_stats(key_id: str, days: int = 30, _=Depends(verify_api_key)): """ 获取 API Key 的调用统计 - **days**: 统计天数，默认 30 天 """ if not API_KEY_AVAILABLE: raise HTTPException(status_code=503, detail="API Key management not available") key_manager = get_api_key_manager() # 验证 key 存在 key = key_manager.get_key_by_id(key_id) if not key: raise HTTPException(status_code=404, detail="API Key not found") stats = key_manager.get_call_stats(key_id, days=days) return ApiStatsResponse( summary=ApiCallStats(**stats["summary"]), endpoints=stats["endpoints"], daily=stats["daily"] ) @app.get("/api/v1/api-keys/{key_id}/logs", response_model=ApiLogsResponse, tags=["API Keys"]) async def get_api_key_logs( key_id: str, limit: int = 100, offset: int = 0, _=Depends(verify_api_key) ): """ 获取 API Key 的调用日志 - **limit**: 返回数量限制 - **offset**: 分页偏移 """ if not API_KEY_AVAILABLE: raise HTTPException(status_code=503, detail="API Key management not available") key_manager = get_api_key_manager() # 验证 key 存在 key = key_manager.get_key_by_id(key_id) if not key: raise HTTPException(status_code=404, detail="API Key not found") logs = key_manager.get_call_logs(key_id, limit=limit, offset=offset) return ApiLogsResponse( logs=[ ApiCallLog( id=log["id"], endpoint=log["endpoint"], method=log["method"], status_code=log["status_code"], response_time_ms=log["response_time_ms"], ip_address=log["ip_address"], user_agent=log["user_agent"], error_message=log["error_message"], created_at=log["created_at"] ) for log in logs ], total=len(logs) ) @app.get("/api/v1/rate-limit/status", response_model=RateLimitStatus, tags=["API Keys"]) async def get_rate_limit_status(request: Request, _=Depends(verify_api_key)): """获取当前请求的限流状态""" if not RATE_LIMITER_AVAILABLE: return RateLimitStatus( limit=60, remaining=60, reset_time=int(time.time()) + 60, window="minute" ) limiter = get_rate_limiter() # 获取限流键 if hasattr(request.state, 'api_key') and request.state.api_key: api_key = request.state.api_key limit_key = f"api_key:{api_key.id}" limit = api_key.rate_limit else: client_ip = request.client.host if request.client else "unknown" limit_key = f"ip:{client_ip}" limit = 10 info = await limiter.get_limit_info(limit_key) return RateLimitStatus( limit=limit, remaining=info.remaining, reset_time=info.reset_time, window="minute" ) # ==================== Phase 6: System Endpoints ==================== @app.get("/api/v1/health", tags=["System"]) async def health_check(): """健康检查端点""" return { "status": "healthy", "version": "0.7.0", "timestamp": datetime.now().isoformat() } @app.get("/api/v1/status", tags=["System"]) async def system_status(): """系统状态信息""" status = { "version": "0.7.0", "phase": "Phase 7 - Plugin & Integration", "features": { "database": DB_AVAILABLE, "oss": OSS_AVAILABLE, "tingwu": TINGWU_AVAILABLE, "llm": LLM_CLIENT_AVAILABLE, "neo4j": NEO4J_AVAILABLE, "export": EXPORT_AVAILABLE, "api_keys": API_KEY_AVAILABLE, "rate_limiting": RATE_LIMITER_AVAILABLE, "workflow": WORKFLOW_AVAILABLE, "multimodal": MULTIMODAL_AVAILABLE, "multimodal_linker": MULTIMODAL_LINKER_AVAILABLE, "plugin_manager": PLUGIN_MANAGER_AVAILABLE, }, "api": { "documentation": "/docs", "openapi": "/openapi.json", }, "timestamp": datetime.now().isoformat() } return status # ==================== Phase 7: Workflow Automation Endpoints ==================== # Workflow Manager singleton _workflow_manager = None def get_workflow_manager_instance(): global _workflow_manager if _workflow_manager is None and WORKFLOW_AVAILABLE and DB_AVAILABLE: from workflow_manager import WorkflowManager db = get_db_manager() _workflow_manager = WorkflowManager(db) _workflow_manager.start() return _workflow_manager @app.post("/api/v1/workflows", response_model=WorkflowResponse, tags=["Workflows"]) async def create_workflow_endpoint(request: WorkflowCreate, _=Depends(verify_api_key)): """ 创建工作流 工作流类型: - **auto_analyze**: 自动分析新上传的文件 - **auto_align**: 自动实体对齐 - **auto_relation**: 自动关系发现 - **scheduled_report**: 定时报告 - **custom**: 自定义工作流 调度类型: - **manual**: 手动触发 - **cron**: Cron 表达式调度 - **interval**: 间隔调度（分钟数） 定时规则示例: - `0 9 * * *` - 每天上午9点 (cron) - `60` - 每60分钟执行一次 (interval) """ if not WORKFLOW_AVAILABLE: raise HTTPException(status_code=503, detail="Workflow automation not available") manager = get_workflow_manager_instance() try: workflow = Workflow( id=str(uuid.uuid4())[:8], name=request.name, description=request.description, workflow_type=request.workflow_type, project_id=request.project_id, schedule=request.schedule, schedule_type=request.schedule_type, config=request.config, webhook_ids=request.webhook_ids ) created = manager.create_workflow(workflow) return WorkflowResponse( id=created.id, name=created.name, description=created.description, workflow_type=created.workflow_type, project_id=created.project_id, status=created.status, schedule=created.schedule, schedule_type=created.schedule_type, config=created.config, webhook_ids=created.webhook_ids, is_active=created.is_active, created_at=created.created_at, updated_at=created.updated_at, last_run_at=created.last_run_at, next_run_at=created.next_run_at, run_count=created.run_count, success_count=created.success_count, fail_count=created.fail_count ) except ValueError as e: raise HTTPException(status_code=400, detail=str(e)) @app.get("/api/v1/workflows", response_model=WorkflowListResponse, tags=["Workflows"]) async def list_workflows_endpoint( project_id: Optional[str] = None, status: Optional[str] = None, workflow_type: Optional[str] = None, _=Depends(verify_api_key) ): """获取工作流列表""" if not WORKFLOW_AVAILABLE: raise HTTPException(status_code=503, detail="Workflow automation not available") manager = get_workflow_manager_instance() workflows = manager.list_workflows(project_id, status, workflow_type) return WorkflowListResponse( workflows=[ WorkflowResponse( id=w.id, name=w.name, description=w.description, workflow_type=w.workflow_type, project_id=w.project_id, status=w.status, schedule=w.schedule, schedule_type=w.schedule_type, config=w.config, webhook_ids=w.webhook_ids, is_active=w.is_active, created_at=w.created_at, updated_at=w.updated_at, last_run_at=w.last_run_at, next_run_at=w.next_run_at, run_count=w.run_count, success_count=w.success_count, fail_count=w.fail_count ) for w in workflows ], total=len(workflows) ) @app.get("/api/v1/workflows/{workflow_id}", response_model=WorkflowResponse, tags=["Workflows"]) async def get_workflow_endpoint(workflow_id: str, _=Depends(verify_api_key)): """获取单个工作流详情""" if not WORKFLOW_AVAILABLE: raise HTTPException(status_code=503, detail="Workflow automation not available") manager = get_workflow_manager_instance() workflow = manager.get_workflow(workflow_id) if not workflow: raise HTTPException(status_code=404, detail="Workflow not found") return WorkflowResponse( id=workflow.id, name=workflow.name, description=workflow.description, workflow_type=workflow.workflow_type, project_id=workflow.project_id, status=workflow.status, schedule=workflow.schedule, schedule_type=workflow.schedule_type, config=workflow.config, webhook_ids=workflow.webhook_ids, is_active=workflow.is_active, created_at=workflow.created_at, updated_at=workflow.updated_at, last_run_at=workflow.last_run_at, next_run_at=workflow.next_run_at, run_count=workflow.run_count, success_count=workflow.success_count, fail_count=workflow.fail_count ) @app.patch("/api/v1/workflows/{workflow_id}", response_model=WorkflowResponse, tags=["Workflows"]) async def update_workflow_endpoint(workflow_id: str, request: WorkflowUpdate, _=Depends(verify_api_key)): """更新工作流""" if not WORKFLOW_AVAILABLE: raise HTTPException(status_code=503, detail="Workflow automation not available") manager = get_workflow_manager_instance() update_data = {k: v for k, v in request.dict().items() if v is not None} updated = manager.update_workflow(workflow_id, **update_data) if not updated: raise HTTPException(status_code=404, detail="Workflow not found") return WorkflowResponse( id=updated.id, name=updated.name, description=updated.description, workflow_type=updated.workflow_type, project_id=updated.project_id, status=updated.status, schedule=updated.schedule, schedule_type=updated.schedule_type, config=updated.config, webhook_ids=updated.webhook_ids, is_active=updated.is_active, created_at=updated.created_at, updated_at=updated.updated_at, last_run_at=updated.last_run_at, next_run_at=updated.next_run_at, run_count=updated.run_count, success_count=updated.success_count, fail_count=updated.fail_count ) @app.delete("/api/v1/workflows/{workflow_id}", tags=["Workflows"]) async def delete_workflow_endpoint(workflow_id: str, _=Depends(verify_api_key)): """删除工作流""" if not WORKFLOW_AVAILABLE: raise HTTPException(status_code=503, detail="Workflow automation not available") manager = get_workflow_manager_instance() success = manager.delete_workflow(workflow_id) if not success: raise HTTPException(status_code=404, detail="Workflow not found") return {"success": True, "message": "Workflow deleted successfully"} @app.post("/api/v1/workflows/{workflow_id}/trigger", response_model=WorkflowTriggerResponse, tags=["Workflows"]) async def trigger_workflow_endpoint(workflow_id: str, request: WorkflowTriggerRequest = None, _=Depends(verify_api_key)): """手动触发工作流""" if not WORKFLOW_AVAILABLE: raise HTTPException(status_code=503, detail="Workflow automation not available") manager = get_workflow_manager_instance() try: result = await manager.execute_workflow( workflow_id, input_data=request.input_data if request else {} ) return WorkflowTriggerResponse( success=result["success"], workflow_id=result["workflow_id"], log_id=result["log_id"], results=result["results"], duration_ms=result["duration_ms"] ) except ValueError as e: raise HTTPException(status_code=404, detail=str(e)) except Exception as e: raise HTTPException(status_code=500, detail=str(e)) @app.get("/api/v1/workflows/{workflow_id}/logs", response_model=WorkflowLogListResponse, tags=["Workflows"]) async def get_workflow_logs_endpoint( workflow_id: str, status: Optional[str] = None, limit: int = 100, offset: int = 0, _=Depends(verify_api_key) ): """获取工作流执行日志""" if not WORKFLOW_AVAILABLE: raise HTTPException(status_code=503, detail="Workflow automation not available") manager = get_workflow_manager_instance() logs = manager.list_logs(workflow_id=workflow_id, status=status, limit=limit, offset=offset) return WorkflowLogListResponse( logs=[ WorkflowLogResponse( id=log.id, workflow_id=log.workflow_id, task_id=log.task_id, status=log.status, start_time=log.start_time, end_time=log.end_time, duration_ms=log.duration_ms, input_data=log.input_data, output_data=log.output_data, error_message=log.error_message, created_at=log.created_at ) for log in logs ], total=len(logs) ) @app.get("/api/v1/workflows/{workflow_id}/stats", response_model=WorkflowStatsResponse, tags=["Workflows"]) async def get_workflow_stats_endpoint(workflow_id: str, days: int = 30, _=Depends(verify_api_key)): """获取工作流执行统计""" if not WORKFLOW_AVAILABLE: raise HTTPException(status_code=503, detail="Workflow automation not available") manager = get_workflow_manager_instance() stats = manager.get_workflow_stats(workflow_id, days) return WorkflowStatsResponse(**stats) # ==================== Phase 7: Webhook Endpoints ==================== @app.post("/api/v1/webhooks", response_model=WebhookResponse, tags=["Webhooks"]) async def create_webhook_endpoint(request: WebhookCreate, _=Depends(verify_api_key)): """ 创建 Webhook 配置 Webhook 类型: - **feishu**: 飞书机器人 - **dingtalk**: 钉钉机器人 - **slack**: Slack Incoming Webhook - **custom**: 自定义 Webhook """ if not WORKFLOW_AVAILABLE: raise HTTPException(status_code=503, detail="Workflow automation not available") manager = get_workflow_manager_instance() try: webhook = WebhookConfig( id=str(uuid.uuid4())[:8], name=request.name, webhook_type=request.webhook_type, url=request.url, secret=request.secret, headers=request.headers, template=request.template ) created = manager.create_webhook(webhook) return WebhookResponse( id=created.id, name=created.name, webhook_type=created.webhook_type, url=created.url, headers=created.headers, template=created.template, is_active=created.is_active, created_at=created.created_at, updated_at=created.updated_at, last_used_at=created.last_used_at, success_count=created.success_count, fail_count=created.fail_count ) except ValueError as e: raise HTTPException(status_code=400, detail=str(e)) @app.get("/api/v1/webhooks", response_model=WebhookListResponse, tags=["Webhooks"]) async def list_webhooks_endpoint(_=Depends(verify_api_key)): """获取 Webhook 列表""" if not WORKFLOW_AVAILABLE: raise HTTPException(status_code=503, detail="Workflow automation not available") manager = get_workflow_manager_instance() webhooks = manager.list_webhooks() return WebhookListResponse( webhooks=[ WebhookResponse( id=w.id, name=w.name, webhook_type=w.webhook_type, url=w.url, headers=w.headers, template=w.template, is_active=w.is_active, created_at=w.created_at, updated_at=w.updated_at, last_used_at=w.last_used_at, success_count=w.success_count, fail_count=w.fail_count ) for w in webhooks ], total=len(webhooks) ) @app.get("/api/v1/webhooks/{webhook_id}", response_model=WebhookResponse, tags=["Webhooks"]) async def get_webhook_endpoint(webhook_id: str, _=Depends(verify_api_key)): """获取单个 Webhook 详情""" if not WORKFLOW_AVAILABLE: raise HTTPException(status_code=503, detail="Workflow automation not available") manager = get_workflow_manager_instance() webhook = manager.get_webhook(webhook_id) if not webhook: raise HTTPException(status_code=404, detail="Webhook not found") return WebhookResponse( id=webhook.id, name=webhook.name, webhook_type=webhook.webhook_type, url=webhook.url, headers=webhook.headers, template=webhook.template, is_active=webhook.is_active, created_at=webhook.created_at, updated_at=webhook.updated_at, last_used_at=webhook.last_used_at, success_count=webhook.success_count, fail_count=webhook.fail_count ) @app.patch("/api/v1/webhooks/{webhook_id}", response_model=WebhookResponse, tags=["Webhooks"]) async def update_webhook_endpoint(webhook_id: str, request: WebhookUpdate, _=Depends(verify_api_key)): """更新 Webhook 配置""" if not WORKFLOW_AVAILABLE: raise HTTPException(status_code=503, detail="Workflow automation not available") manager = get_workflow_manager_instance() update_data = {k: v for k, v in request.dict().items() if v is not None} updated = manager.update_webhook(webhook_id, **update_data) if not updated: raise HTTPException(status_code=404, detail="Webhook not found") return WebhookResponse( id=updated.id, name=updated.name, webhook_type=updated.webhook_type, url=updated.url, headers=updated.headers, template=updated.template, is_active=updated.is_active, created_at=updated.created_at, updated_at=updated.updated_at, last_used_at=updated.last_used_at, success_count=updated.success_count, fail_count=updated.fail_count ) @app.delete("/api/v1/webhooks/{webhook_id}", tags=["Webhooks"]) async def delete_webhook_endpoint(webhook_id: str, _=Depends(verify_api_key)): """删除 Webhook 配置""" if not WORKFLOW_AVAILABLE: raise HTTPException(status_code=503, detail="Workflow automation not available") manager = get_workflow_manager_instance() success = manager.delete_webhook(webhook_id) if not success: raise HTTPException(status_code=404, detail="Webhook not found") return {"success": True, "message": "Webhook deleted successfully"} @app.post("/api/v1/webhooks/{webhook_id}/test", tags=["Webhooks"]) async def test_webhook_endpoint(webhook_id: str, _=Depends(verify_api_key)): """测试 Webhook 配置""" if not WORKFLOW_AVAILABLE: raise HTTPException(status_code=503, detail="Workflow automation not available") manager = get_workflow_manager_instance() webhook = manager.get_webhook(webhook_id) if not webhook: raise HTTPException(status_code=404, detail="Webhook not found") # 构建测试消息 test_message = { "content": "🔔 这是来自 InsightFlow 的 Webhook 测试消息\n\n如果您收到这条消息，说明 Webhook 配置正确！" } if webhook.webhook_type == "slack": test_message = {"text": "🔔 这是来自 InsightFlow 的 Webhook 测试消息\n\n如果您收到这条消息，说明 Webhook 配置正确！"} success = await manager.notifier.send(webhook, test_message) manager.update_webhook_stats(webhook_id, success) if success: return {"success": True, "message": "Webhook test sent successfully"} else: raise HTTPException(status_code=400, detail="Webhook test failed") # ==================== Phase 7: Multimodal Support Endpoints ==================== # Pydantic Models for Multimodal API class VideoUploadResponse(BaseModel): video_id: str project_id: str filename: str status: str audio_extracted: bool frame_count: int ocr_text_preview: str message: str class ImageUploadResponse(BaseModel): image_id: str project_id: str filename: str image_type: str ocr_text_preview: str description: str entity_count: int status: str class MultimodalEntityLinkResponse(BaseModel): link_id: str source_entity_id: str target_entity_id: str source_modality: str target_modality: str link_type: str confidence: float evidence: str class MultimodalAlignmentRequest(BaseModel): project_id: str threshold: float = 0.85 class MultimodalAlignmentResponse(BaseModel): project_id: str aligned_count: int links: List[MultimodalEntityLinkResponse] message: str class MultimodalStatsResponse(BaseModel): project_id: str video_count: int image_count: int multimodal_entity_count: int cross_modal_links: int modality_distribution: Dict[str, int] @app.post("/api/v1/projects/{project_id}/upload-video", response_model=VideoUploadResponse, tags=["Multimodal"]) async def upload_video_endpoint( project_id: str, file: UploadFile = File(...), extract_interval: int = Form(5), _=Depends(verify_api_key) ): """ 上传视频文件进行处理 - 提取音频轨道 - 提取关键帧（每 N 秒一帧） - 对关键帧进行 OCR 识别 - 将视频、音频、OCR 结果整合 **参数:** - **extract_interval**: 关键帧提取间隔（秒），默认 5 秒 """ if not MULTIMODAL_AVAILABLE: raise HTTPException(status_code=503, detail="Multimodal processing not available") if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") # 读取视频文件 video_data = await file.read() # 创建视频处理器 processor = get_multimodal_processor(frame_interval=extract_interval) # 处理视频 video_id = str(uuid.uuid4())[:8] result = processor.process_video(video_data, file.filename, project_id, video_id) if not result.success: raise HTTPException(status_code=500, detail=f"Video processing failed: {result.error_message}") # 保存视频信息到数据库 conn = db.get_conn() now = datetime.now().isoformat() # 获取视频信息 video_info = processor.extract_video_info(os.path.join(processor.video_dir, f"{video_id}_{file.filename}")) conn.execute( """INSERT INTO videos (id, project_id, filename, duration, fps, resolution, audio_transcript_id, full_ocr_text, extracted_entities, extracted_relations, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""", (video_id, project_id, file.filename, video_info.get('duration', 0), video_info.get('fps', 0), json.dumps({'width': video_info.get('width', 0), 'height': video_info.get('height', 0)}), None, result.full_text, '[]', '[]', 'completed', now, now) ) # 保存关键帧信息 for frame in result.frames: conn.execute( """INSERT INTO video_frames (id, video_id, frame_number, timestamp, image_url, ocr_text, extracted_entities, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)""", (frame.id, frame.video_id, frame.frame_number, frame.timestamp, frame.frame_path, frame.ocr_text, json.dumps(frame.entities_detected), now) ) conn.commit() conn.close() # 提取实体和关系（复用现有的 LLM 提取逻辑） if result.full_text: raw_entities, raw_relations = extract_entities_with_llm(result.full_text) # 实体对齐并保存 entity_name_to_id = {} for raw_ent in raw_entities: existing = align_entity(project_id, raw_ent["name"], db, raw_ent.get("definition", "")) if existing: entity_name_to_id[raw_ent["name"]] = existing.id else: new_ent = db.create_entity(Entity( id=str(uuid.uuid4())[:8], project_id=project_id, name=raw_ent["name"], type=raw_ent.get("type", "OTHER"), definition=raw_ent.get("definition", "") )) entity_name_to_id[raw_ent["name"]] = new_ent.id # 保存多模态实体提及 conn = db.get_conn() conn.execute( """INSERT OR REPLACE INTO multimodal_mentions (id, project_id, entity_id, modality, source_id, source_type, text_snippet, confidence, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)""", (str(uuid.uuid4())[:8], project_id, entity_name_to_id[raw_ent["name"]], 'video', video_id, 'video_frame', raw_ent.get("name", ""), 1.0, now) ) conn.commit() conn.close() # 保存关系 for rel in raw_relations: source_id = entity_name_to_id.get(rel.get("source", "")) target_id = entity_name_to_id.get(rel.get("target", "")) if source_id and target_id: db.create_relation( project_id=project_id, source_entity_id=source_id, target_entity_id=target_id, relation_type=rel.get("type", "related"), evidence=result.full_text[:200] ) # 更新视频的实体和关系信息 conn = db.get_conn() conn.execute( "UPDATE videos SET extracted_entities = ?, extracted_relations = ? WHERE id = ?", (json.dumps(raw_entities), json.dumps(raw_relations), video_id) ) conn.commit() conn.close() return VideoUploadResponse( video_id=video_id, project_id=project_id, filename=file.filename, status="completed", audio_extracted=bool(result.audio_path), frame_count=len(result.frames), ocr_text_preview=result.full_text[:200] + "..." if len(result.full_text) > 200 else result.full_text, message="Video processed successfully" ) @app.post("/api/v1/projects/{project_id}/upload-image", response_model=ImageUploadResponse, tags=["Multimodal"]) async def upload_image_endpoint( project_id: str, file: UploadFile = File(...), detect_type: bool = Form(True), _=Depends(verify_api_key) ): """ 上传图片文件进行处理 - 图片内容识别（白板、PPT、手写笔记） - 使用 OCR 识别图片中的文字 - 提取图片中的实体和关系 **参数:** - **detect_type**: 是否自动检测图片类型，默认 True """ if not IMAGE_PROCESSOR_AVAILABLE: raise HTTPException(status_code=503, detail="Image processing not available") if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") # 读取图片文件 image_data = await file.read() # 创建图片处理器 processor = get_image_processor() # 处理图片 image_id = str(uuid.uuid4())[:8] result = processor.process_image(image_data, file.filename, image_id, detect_type) if not result.success: raise HTTPException(status_code=500, detail=f"Image processing failed: {result.error_message}") # 保存图片信息到数据库 conn = db.get_conn() now = datetime.now().isoformat() conn.execute( """INSERT INTO images (id, project_id, filename, ocr_text, description, extracted_entities, extracted_relations, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""", (image_id, project_id, file.filename, result.ocr_text, result.description, json.dumps([{"name": e.name, "type": e.type, "confidence": e.confidence} for e in result.entities]), json.dumps([{"source": r.source, "target": r.target, "type": r.relation_type} for r in result.relations]), 'completed', now, now) ) conn.commit() conn.close() # 保存提取的实体 for entity in result.entities: existing = align_entity(project_id, entity.name, db, "") if not existing: new_ent = db.create_entity(Entity( id=str(uuid.uuid4())[:8], project_id=project_id, name=entity.name, type=entity.type, definition="" )) entity_id = new_ent.id else: entity_id = existing.id # 保存多模态实体提及 conn = db.get_conn() conn.execute( """INSERT OR REPLACE INTO multimodal_mentions (id, project_id, entity_id, modality, source_id, source_type, text_snippet, confidence, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)""", (str(uuid.uuid4())[:8], project_id, entity_id, 'image', image_id, result.image_type, entity.name, entity.confidence, now) ) conn.commit() conn.close() # 保存提取的关系 for relation in result.relations: source_entity = db.get_entity_by_name(project_id, relation.source) target_entity = db.get_entity_by_name(project_id, relation.target) if source_entity and target_entity: db.create_relation( project_id=project_id, source_entity_id=source_entity.id, target_entity_id=target_entity.id, relation_type=relation.relation_type, evidence=result.ocr_text[:200] ) return ImageUploadResponse( image_id=image_id, project_id=project_id, filename=file.filename, image_type=result.image_type, ocr_text_preview=result.ocr_text[:200] + "..." if len(result.ocr_text) > 200 else result.ocr_text, description=result.description, entity_count=len(result.entities), status="completed" ) @app.post("/api/v1/projects/{project_id}/upload-images-batch", tags=["Multimodal"]) async def upload_images_batch_endpoint( project_id: str, files: List[UploadFile] = File(...), _=Depends(verify_api_key) ): """ 批量上传图片文件进行处理 支持一次上传多张图片，每张图片都会进行 OCR 和实体提取 """ if not IMAGE_PROCESSOR_AVAILABLE: raise HTTPException(status_code=503, detail="Image processing not available") if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") # 读取所有图片 images_data = [] for file in files: image_data = await file.read() images_data.append((image_data, file.filename)) # 批量处理 processor = get_image_processor() batch_result = processor.process_batch(images_data, project_id) # 保存结果 results = [] for result in batch_result.results: if result.success: image_id = result.image_id # 保存到数据库 conn = db.get_conn() now = datetime.now().isoformat() conn.execute( """INSERT INTO images (id, project_id, filename, ocr_text, description, extracted_entities, extracted_relations, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""", (image_id, project_id, "batch_image", result.ocr_text, result.description, json.dumps([{"name": e.name, "type": e.type} for e in result.entities]), json.dumps([{"source": r.source, "target": r.target} for r in result.relations]), 'completed', now, now) ) conn.commit() conn.close() results.append({ "image_id": image_id, "status": "success", "image_type": result.image_type, "entity_count": len(result.entities) }) else: results.append({ "image_id": result.image_id, "status": "failed", "error": result.error_message }) return { "project_id": project_id, "total_count": batch_result.total_count, "success_count": batch_result.success_count, "failed_count": batch_result.failed_count, "results": results } @app.post("/api/v1/projects/{project_id}/multimodal/align", response_model=MultimodalAlignmentResponse, tags=["Multimodal"]) async def align_multimodal_entities_endpoint( project_id: str, threshold: float = 0.85, _=Depends(verify_api_key) ): """ 跨模态实体对齐 对齐同一实体在不同模态（音频、视频、图片、文档）中的提及 **参数:** - **threshold**: 相似度阈值，默认 0.85 """ if not MULTIMODAL_LINKER_AVAILABLE: raise HTTPException(status_code=503, detail="Multimodal entity linker not available") if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") # 获取所有实体 entities = db.list_project_entities(project_id) # 获取多模态提及 conn = db.get_conn() mentions = conn.execute( """SELECT * FROM multimodal_mentions WHERE project_id = ?""", (project_id,) ).fetchall() conn.close() # 按模态分组实体 modality_entities = {"audio": [], "video": [], "image": [], "document": []} for mention in mentions: modality = mention['modality'] entity = db.get_entity(mention['entity_id']) if entity and entity.id not in [e.get('id') for e in modality_entities[modality]]: modality_entities[modality].append({ 'id': entity.id, 'name': entity.name, 'type': entity.type, 'definition': entity.definition, 'aliases': entity.aliases }) # 跨模态对齐 linker = get_multimodal_entity_linker(similarity_threshold=threshold) links = linker.align_cross_modal_entities( project_id=project_id, audio_entities=modality_entities['audio'], video_entities=modality_entities['video'], image_entities=modality_entities['image'], document_entities=modality_entities['document'] ) # 保存关联到数据库 conn = db.get_conn() now = datetime.now().isoformat() saved_links = [] for link in links: conn.execute( """INSERT OR REPLACE INTO multimodal_entity_links (id, entity_id, linked_entity_id, link_type, confidence, evidence, modalities, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)""", (link.id, link.source_entity_id, link.target_entity_id, link.link_type, link.confidence, link.evidence, json.dumps([link.source_modality, link.target_modality]), now) ) saved_links.append(MultimodalEntityLinkResponse( link_id=link.id, source_entity_id=link.source_entity_id, target_entity_id=link.target_entity_id, source_modality=link.source_modality, target_modality=link.target_modality, link_type=link.link_type, confidence=link.confidence, evidence=link.evidence )) conn.commit() conn.close() return MultimodalAlignmentResponse( project_id=project_id, aligned_count=len(saved_links), links=saved_links, message=f"Successfully aligned {len(saved_links)} cross-modal entity pairs" ) @app.get("/api/v1/projects/{project_id}/multimodal/stats", response_model=MultimodalStatsResponse, tags=["Multimodal"]) async def get_multimodal_stats_endpoint(project_id: str, _=Depends(verify_api_key)): """ 获取项目多模态统计信息 返回项目中视频、图片数量，以及跨模态实体关联统计 """ if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") conn = db.get_conn() # 统计视频数量 video_count = conn.execute( "SELECT COUNT(*) as count FROM videos WHERE project_id = ?", (project_id,) ).fetchone()['count'] # 统计图片数量 image_count = conn.execute( "SELECT COUNT(*) as count FROM images WHERE project_id = ?", (project_id,) ).fetchone()['count'] # 统计多模态实体提及 multimodal_count = conn.execute( "SELECT COUNT(DISTINCT entity_id) as count FROM multimodal_mentions WHERE project_id = ?", (project_id,) ).fetchone()['count'] # 统计跨模态关联 cross_modal_count = conn.execute( "SELECT COUNT(*) as count FROM multimodal_entity_links WHERE entity_id IN (SELECT id FROM entities WHERE project_id = ?)", (project_id,) ).fetchone()['count'] # 模态分布 modality_dist = {} for modality in ['audio', 'video', 'image', 'document']: count = conn.execute( "SELECT COUNT(*) as count FROM multimodal_mentions WHERE project_id = ? AND modality = ?", (project_id, modality) ).fetchone()['count'] modality_dist[modality] = count conn.close() return MultimodalStatsResponse( project_id=project_id, video_count=video_count, image_count=image_count, multimodal_entity_count=multimodal_count, cross_modal_links=cross_modal_count, modality_distribution=modality_dist ) @app.get("/api/v1/projects/{project_id}/videos", tags=["Multimodal"]) async def list_project_videos_endpoint(project_id: str, _=Depends(verify_api_key)): """获取项目的视频列表""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() conn = db.get_conn() videos = conn.execute( """SELECT id, filename, duration, fps, resolution, full_ocr_text, status, created_at FROM videos WHERE project_id = ? ORDER BY created_at DESC""", (project_id,) ).fetchall() conn.close() return [{ "id": v['id'], "filename": v['filename'], "duration": v['duration'], "fps": v['fps'], "resolution": json.loads(v['resolution']) if v['resolution'] else None, "ocr_preview": v['full_ocr_text'][:200] + "..." if v['full_ocr_text'] and len(v['full_ocr_text']) > 200 else v['full_ocr_text'], "status": v['status'], "created_at": v['created_at'] } for v in videos] @app.get("/api/v1/projects/{project_id}/images", tags=["Multimodal"]) async def list_project_images_endpoint(project_id: str, _=Depends(verify_api_key)): """获取项目的图片列表""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() conn = db.get_conn() images = conn.execute( """SELECT id, filename, ocr_text, description, extracted_entities, status, created_at FROM images WHERE project_id = ? ORDER BY created_at DESC""", (project_id,) ).fetchall() conn.close() return [{ "id": img['id'], "filename": img['filename'], "ocr_preview": img['ocr_text'][:200] + "..." if img['ocr_text'] and len(img['ocr_text']) > 200 else img['ocr_text'], "description": img['description'], "entity_count": len(json.loads(img['extracted_entities'])) if img['extracted_entities'] else 0, "status": img['status'], "created_at": img['created_at'] } for img in images] @app.get("/api/v1/videos/{video_id}/frames", tags=["Multimodal"]) async def get_video_frames_endpoint(video_id: str, _=Depends(verify_api_key)): """获取视频的关键帧列表""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() conn = db.get_conn() frames = conn.execute( """SELECT id, frame_number, timestamp, image_url, ocr_text, extracted_entities FROM video_frames WHERE video_id = ? ORDER BY timestamp""", (video_id,) ).fetchall() conn.close() return [{ "id": f['id'], "frame_number": f['frame_number'], "timestamp": f['timestamp'], "image_url": f['image_url'], "ocr_text": f['ocr_text'], "entities": json.loads(f['extracted_entities']) if f['extracted_entities'] else [] } for f in frames] @app.get("/api/v1/entities/{entity_id}/multimodal-mentions", tags=["Multimodal"]) async def get_entity_multimodal_mentions_endpoint(entity_id: str, _=Depends(verify_api_key)): """获取实体的多模态提及信息""" if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() conn = db.get_conn() mentions = conn.execute( """SELECT m.*, e.name as entity_name FROM multimodal_mentions m JOIN entities e ON m.entity_id = e.id WHERE m.entity_id = ? ORDER BY m.created_at DESC""", (entity_id,) ).fetchall() conn.close() return [{ "id": m['id'], "entity_id": m['entity_id'], "entity_name": m['entity_name'], "modality": m['modality'], "source_id": m['source_id'], "source_type": m['source_type'], "text_snippet": m['text_snippet'], "confidence": m['confidence'], "created_at": m['created_at'] } for m in mentions] @app.get("/api/v1/projects/{project_id}/multimodal/suggest-merges", tags=["Multimodal"]) async def suggest_multimodal_merges_endpoint(project_id: str, _=Depends(verify_api_key)): """ 建议多模态实体合并 分析不同模态中的实体，建议可以合并的实体对 """ if not MULTIMODAL_LINKER_AVAILABLE: raise HTTPException(status_code=503, detail="Multimodal entity linker not available") if not DB_AVAILABLE: raise HTTPException(status_code=500, detail="Database not available") db = get_db_manager() project = db.get_project(project_id) if not project: raise HTTPException(status_code=404, detail="Project not found") # 获取所有实体 entities = db.list_project_entities(project_id) entity_dicts = [{ 'id': e.id, 'name': e.name, 'type': e.type, 'definition': e.definition, 'aliases': e.aliases } for e in entities] # 获取现有链接 conn = db.get_conn() existing_links = conn.execute( """SELECT * FROM multimodal_entity_links WHERE entity_id IN (SELECT id FROM entities WHERE project_id = ?)""", (project_id,) ).fetchall() conn.close() existing_link_objects = [] for row in existing_links: existing_link_objects.append(EntityLink( id=row['id'], project_id=project_id, source_entity_id=row['entity_id'], target_entity_id=row['linked_entity_id'], link_type=row['link_type'], source_modality='unknown', target_modality='unknown', confidence=row['confidence'], evidence=row['evidence'] or "" )) # 获取建议 linker = get_multimodal_entity_linker() suggestions = linker.suggest_entity_merges(entity_dicts, existing_link_objects) return { "project_id": project_id, "suggestion_count": len(suggestions), "suggestions": [ { "entity1": { "id": s['entity1'].get('id'), "name": s['entity1'].get('name'), "type": s['entity1'].get('type') }, "entity2": { "id": s['entity2'].get('id'), "name": s['entity2'].get('name'), "type": s['entity2'].get('type') }, "similarity": s['similarity'], "match_type": s['match_type'], "suggested_action": s['suggested_action'] } for s in suggestions[:20] # 最多返回20个建议 ] } # ==================== Phase 7: Multimodal Support API ==================== class VideoUploadResponse(BaseModel): video_id: str filename: str duration: float fps: float resolution: Dict[str, int] frames_extracted: int audio_extracted: bool ocr_text_length: int status: str message: str class ImageUploadResponse(BaseModel): image_id: str filename: str ocr_text_length: int description: str status: str message: str class MultimodalEntityLinkResponse(BaseModel): link_id: str entity_id: str linked_entity_id: str link_type: str confidence: float evidence: str modalities: List[str] class MultimodalProfileResponse(BaseModel): entity_id: str entity_name: str @app.get("/api/v1/openapi.json", include_in_schema=False) async def get_openapi(): """获取 OpenAPI 规范""" from fastapi.openapi.utils import get_openapi return get_openapi( title=app.title, version=app.version, description=app.description, routes=app.routes, tags=app.openapi_tags ) # ==================== Phase 7 Task 7: Plugin & Integration API ==================== class PluginCreateRequest(BaseModel): name: str plugin_type: str project_id: Optional[str] = None config: Optional[Dict] = {} class PluginResponse(BaseModel): id: str name: str plugin_type: str project_id: Optional[str] status: str api_key: str created_at: str class BotSessionResponse(BaseModel): id: str plugin_id: str platform: str session_id: str user_id: Optional[str] user_name: Optional[str] project_id: Optional[str] message_count: int created_at: str last_message_at: Optional[str] class WebhookEndpointResponse(BaseModel): id: str plugin_id: str name: str endpoint_path: str endpoint_type: str target_project_id: Optional[str] is_active: bool trigger_count: int created_at: str class WebDAVSyncResponse(BaseModel): id: str plugin_id: str name: str server_url: str username: str remote_path: str local_path: str sync_direction: str sync_mode: str auto_analyze: bool is_active: bool last_sync_at: Optional[str] created_at: str class ChromeClipRequest(BaseModel): url: str title: str content: str content_type: str = "page" meta: Optional[Dict] = {} project_id: Optional[str] = None class ChromeClipResponse(BaseModel): clip_id: str project_id: str url: str title: str status: str message: str class BotMessageRequest(BaseModel): platform: str session_id: str user_id: Optional[str] = None user_name: Optional[str] = None message_type: str content: str project_id: Optional[str] = None class BotMessageResponse(BaseModel): success: bool reply: Optional[str] = None session_id: str action: Optional[str] = None class WebhookPayload(BaseModel): event: str data: Dict @app.post("/api/v1/plugins", response_model=PluginResponse, tags=["Plugins"]) async def create_plugin( request: PluginCreateRequest, api_key: str = Depends(verify_api_key) ): """创建插件""" if not PLUGIN_MANAGER_AVAILABLE: raise HTTPException(status_code=503, detail="Plugin manager not available") manager = get_plugin_manager() plugin = manager.create_plugin( name=request.name, plugin_type=request.plugin_type, project_id=request.project_id, config=request.config ) return PluginResponse( id=plugin.id, name=plugin.name, plugin_type=plugin.plugin_type, project_id=plugin.project_id, status=plugin.status, api_key=plugin.api_key, created_at=plugin.created_at ) @app.get("/api/v1/plugins", tags=["Plugins"]) async def list_plugins( project_id: Optional[str] = None, plugin_type: Optional[str] = None, api_key: str = Depends(verify_api_key) ): """列出插件""" if not PLUGIN_MANAGER_AVAILABLE: raise HTTPException(status_code=503, detail="Plugin manager not available") manager = get_plugin_manager() plugins = manager.list_plugins(project_id=project_id, plugin_type=plugin_type) return { "plugins": [ { "id": p.id, "name": p.name, "plugin_type": p.plugin_type, "project_id": p.project_id, "status": p.status, "use_count": p.use_count, "created_at": p.created_at } for p in plugins ] } @app.get("/api/v1/plugins/{plugin_id}", response_model=PluginResponse, tags=["Plugins"]) async def get_plugin( plugin_id: str, api_key: str = Depends(verify_api_key) ): """获取插件详情""" if not PLUGIN_MANAGER_AVAILABLE: raise HTTPException(status_code=503, detail="Plugin manager not available") manager = get_plugin_manager() plugin = manager.get_plugin(plugin_id) if not plugin: raise HTTPException(status_code=404, detail="Plugin not found") return PluginResponse( id=plugin.id, name=plugin.name, plugin_type=plugin.plugin_type, project_id=plugin.project_id, status=plugin.status, api_key=plugin.api_key, created_at=plugin.created_at ) @app.delete("/api/v1/plugins/{plugin_id}", tags=["Plugins"]) async def delete_plugin( plugin_id: str, api_key: str = Depends(verify_api_key) ): """删除插件""" if not PLUGIN_MANAGER_AVAILABLE: raise HTTPException(status_code=503, detail="Plugin manager not available") manager = get_plugin_manager() manager.delete_plugin(plugin_id) return {"success": True, "message": "Plugin deleted"} @app.post("/api/v1/plugins/{plugin_id}/regenerate-key", tags=["Plugins"]) async def regenerate_plugin_key( plugin_id: str, api_key: str = Depends(verify_api_key) ): """重新生成插件 API Key""" if not PLUGIN_MANAGER_AVAILABLE: raise HTTPException(status_code=503, detail="Plugin manager not available") manager = get_plugin_manager() new_key = manager.regenerate_api_key(plugin_id) return {"success": True, "api_key": new_key} # ==================== Chrome Extension API ==================== @app.post("/api/v1/plugins/chrome/clip", response_model=ChromeClipResponse, tags=["Chrome Extension"]) async def chrome_clip( request: ChromeClipRequest, x_api_key: Optional[str] = Header(None, alias="X-API-Key") ): """Chrome 插件保存网页内容""" if not PLUGIN_MANAGER_AVAILABLE: raise HTTPException(status_code=503, detail="Plugin manager not available") if not x_api_key: raise HTTPException(status_code=401, detail="API Key required") manager = get_plugin_manager() plugin = manager.get_plugin_by_api_key(x_api_key) if not plugin or plugin.plugin_type != "chrome_extension": raise HTTPException(status_code=401, detail="Invalid API Key") # 确定目标项目 project_id = request.project_id or plugin.project_id if not project_id: raise HTTPException(status_code=400, detail="Project ID required") # 创建转录记录（将网页内容作为文档处理） db = get_db_manager() # 生成文档内容 doc_content = f"""# {request.title} URL: {request.url} ## 内容 {request.content} ## 元数据 {json.dumps(request.meta, ensure_ascii=False, indent=2)} """ # 创建转录记录 transcript_id = db.create_transcript( project_id=project_id, filename=f"clip_{request.title[:50]}.md", full_text=doc_content, transcript_type="document" ) # 记录活动 manager.log_activity( plugin_id=plugin.id, activity_type="clip", source="chrome_extension", details={ "url": request.url, "title": request.title, "project_id": project_id, "transcript_id": transcript_id } ) return ChromeClipResponse( clip_id=str(uuid.uuid4()), project_id=project_id, url=request.url, title=request.title, status="success", message="Content saved successfully" ) # ==================== Bot API ==================== @app.post("/api/v1/bots/webhook/{platform}", response_model=BotMessageResponse, tags=["Bot"]) async def bot_webhook( platform: str, request: Request, x_signature: Optional[str] = Header(None, alias="X-Signature") ): """接收机器人 Webhook 消息（飞书/钉钉/Slack）""" if not PLUGIN_MANAGER_AVAILABLE: raise HTTPException(status_code=503, detail="Plugin manager not available") body = await request.body() payload = json.loads(body) manager = get_plugin_manager() handler = BotHandler(manager) # 解析消息 if platform == "feishu": message = handler.parse_feishu_message(payload) elif platform == "dingtalk": message = handler.parse_dingtalk_message(payload) elif platform == "slack": message = handler.parse_slack_message(payload) else: raise HTTPException(status_code=400, detail=f"Unsupported platform: {platform}") # 查找或创建会话 # 这里简化处理，实际应该根据 plugin_id 查找 # 暂时返回简单的回复 return BotMessageResponse( success=True, reply="收到消息！请使用 InsightFlow 控制台查看更多功能。", session_id=message.get("session_id", ""), action="reply" ) @app.get("/api/v1/bots/sessions", response_model=List[BotSessionResponse], tags=["Bot"]) async def list_bot_sessions( plugin_id: Optional[str] = None, project_id: Optional[str] = None, api_key: str = Depends(verify_api_key) ): """列出机器人会话""" if not PLUGIN_MANAGER_AVAILABLE: raise HTTPException(status_code=503, detail="Plugin manager not available") manager = get_plugin_manager() sessions = manager.list_bot_sessions(plugin_id=plugin_id, project_id=project_id) return [ BotSessionResponse( id=s.id, plugin_id=s.plugin_id, platform=s.platform, session_id=s.session_id, user_id=s.user_id, user_name=s.user_name, project_id=s.project_id, message_count=s.message_count, created_at=s.created_at, last_message_at=s.last_message_at ) for s in sessions ] # ==================== Webhook Integration API ==================== @app.post("/api/v1/webhook-endpoints", response_model=WebhookEndpointResponse, tags=["Integrations"]) async def create_webhook_endpoint( plugin_id: str, name: str, endpoint_type: str, target_project_id: Optional[str] = None, allowed_events: Optional[List[str]] = None, api_key: str = Depends(verify_api_key) ): """创建 Webhook 端点（用于 Zapier/Make 集成）""" if not PLUGIN_MANAGER_AVAILABLE: raise HTTPException(status_code=503, detail="Plugin manager not available") manager = get_plugin_manager() endpoint = manager.create_webhook_endpoint( plugin_id=plugin_id, name=name, endpoint_type=endpoint_type, target_project_id=target_project_id, allowed_events=allowed_events ) return WebhookEndpointResponse( id=endpoint.id, plugin_id=endpoint.plugin_id, name=endpoint.name, endpoint_path=endpoint.endpoint_path, endpoint_type=endpoint.endpoint_type, target_project_id=endpoint.target_project_id, is_active=endpoint.is_active, trigger_count=endpoint.trigger_count, created_at=endpoint.created_at ) @app.get("/api/v1/webhook-endpoints", response_model=List[WebhookEndpointResponse], tags=["Integrations"]) async def list_webhook_endpoints( plugin_id: Optional[str] = None, api_key: str = Depends(verify_api_key) ): """列出 Webhook 端点""" if not PLUGIN_MANAGER_AVAILABLE: raise HTTPException(status_code=503, detail="Plugin manager not available") manager = get_plugin_manager() endpoints = manager.list_webhook_endpoints(plugin_id=plugin_id) return [ WebhookEndpointResponse( id=e.id, plugin_id=e.plugin_id, name=e.name, endpoint_path=e.endpoint_path, endpoint_type=e.endpoint_type, target_project_id=e.target_project_id, is_active=e.is_active, trigger_count=e.trigger_count, created_at=e.created_at ) for e in endpoints ] @app.post("/webhook/{endpoint_type}/{token}", tags=["Integrations"]) async def receive_webhook( endpoint_type: str, token: str, request: Request, x_signature: Optional[str] = Header(None, alias="X-Signature") ): """接收外部 Webhook 调用（Zapier/Make/Custom）""" if not PLUGIN_MANAGER_AVAILABLE: raise HTTPException(status_code=503, detail="Plugin manager not available") manager = get_plugin_manager() # 构建完整路径查找端点 path = f"/webhook/{endpoint_type}/{token}" endpoint = manager.get_webhook_endpoint_by_path(path) if not endpoint or not endpoint.is_active: raise HTTPException(status_code=404, detail="Webhook endpoint not found") # 验证签名（如果有） if endpoint.secret and x_signature: body = await request.body() integration = WebhookIntegration(manager) if not integration.validate_signature(body, x_signature, endpoint.secret): raise HTTPException(status_code=401, detail="Invalid signature") # 解析请求体 body = await request.json() # 更新触发统计 manager.update_webhook_trigger(endpoint.id) # 记录活动 manager.log_activity( plugin_id=endpoint.plugin_id, activity_type="webhook", source=endpoint_type, details={ "endpoint_id": endpoint.id, "event": body.get("event"), "data_keys": list(body.get("data", {}).keys()) } ) # 处理数据（简化版本） # 实际应该根据 endpoint.target_project_id 和 body 内容创建文档/实体等 return { "success": True, "endpoint_id": endpoint.id, "received_at": datetime.now().isoformat() } # ==================== WebDAV API ==================== @app.post("/api/v1/webdav-syncs", response_model=WebDAVSyncResponse, tags=["WebDAV"]) async def create_webdav_sync( plugin_id: str, name: str, server_url: str, username: str, password: str, remote_path: str = "/", local_path: str = "./sync", sync_direction: str = "bidirectional", sync_mode: str = "manual", auto_analyze: bool = True, api_key: str = Depends(verify_api_key) ): """创建 WebDAV 同步配置""" if not PLUGIN_MANAGER_AVAILABLE: raise HTTPException(status_code=503, detail="Plugin manager not available") manager = get_plugin_manager() sync = manager.create_webdav_sync( plugin_id=plugin_id, name=name, server_url=server_url, username=username, password=password, remote_path=remote_path, local_path=local_path, sync_direction=sync_direction, sync_mode=sync_mode, auto_analyze=auto_analyze ) return WebDAVSyncResponse( id=sync.id, plugin_id=sync.plugin_id, name=sync.name, server_url=sync.server_url, username=sync.username, remote_path=sync.remote_path, local_path=sync.local_path, sync_direction=sync.sync_direction, sync_mode=sync.sync_mode, auto_analyze=sync.auto_analyze, is_active=sync.is_active, last_sync_at=sync.last_sync_at, created_at=sync.created_at ) @app.get("/api/v1/webdav-syncs", response_model=List[WebDAVSyncResponse], tags=["WebDAV"]) async def list_webdav_syncs( plugin_id: Optional[str] = None, api_key: str = Depends(verify_api_key) ): """列出 WebDAV 同步配置""" if not PLUGIN_MANAGER_AVAILABLE: raise HTTPException(status_code=503, detail="Plugin manager not available") manager = get_plugin_manager() syncs = manager.list_webdav_syncs(plugin_id=plugin_id) return [ WebDAVSyncResponse( id=s.id, plugin_id=s.plugin_id, name=s.name, server_url=s.server_url, username=s.username, remote_path=s.remote_path, local_path=s.local_path, sync_direction=s.sync_direction, sync_mode=s.sync_mode, auto_analyze=s.auto_analyze, is_active=s.is_active, last_sync_at=s.last_sync_at, created_at=s.created_at ) for s in syncs ] @app.post("/api/v1/webdav-syncs/{sync_id}/test", tags=["WebDAV"]) async def test_webdav_connection( sync_id: str, api_key: str = Depends(verify_api_key) ): """测试 WebDAV 连接""" if not PLUGIN_MANAGER_AVAILABLE: raise HTTPException(status_code=503, detail="Plugin manager not available") manager = get_plugin_manager() sync = manager.get_webdav_sync(sync_id) if not sync: raise HTTPException(status_code=404, detail="WebDAV sync not found") from plugin_manager import WebDAVSync as WebDAVSyncHandler handler = WebDAVSyncHandler(manager) success, message = await handler.test_connection( sync.server_url, sync.username, sync.password ) return {"success": success, "message": message} @app.post("/api/v1/webdav-syncs/{sync_id}/sync", tags=["WebDAV"]) async def trigger_webdav_sync( sync_id: str, api_key: str = Depends(verify_api_key) ): """手动触发 WebDAV 同步""" if not PLUGIN_MANAGER_AVAILABLE: raise HTTPException(status_code=503, detail="Plugin manager not available") manager = get_plugin_manager() sync = manager.get_webdav_sync(sync_id) if not sync: raise HTTPException(status_code=404, detail="WebDAV sync not found") # 这里应该启动异步同步任务 # 简化版本，仅返回成功 manager.update_webdav_sync( sync_id, last_sync_at=datetime.now().isoformat(), last_sync_status="running" ) return { "success": True, "sync_id": sync_id, "status": "running", "message": "Sync started" } # ==================== Plugin Activity Logs ==================== @app.get("/api/v1/plugins/{plugin_id}/logs", tags=["Plugins"]) async def get_plugin_logs( plugin_id: str, activity_type: Optional[str] = None, limit: int = 100, api_key: str = Depends(verify_api_key) ): """获取插件活动日志""" if not PLUGIN_MANAGER_AVAILABLE: raise HTTPException(status_code=503, detail="Plugin manager not available") manager = get_plugin_manager() logs = manager.get_activity_logs( plugin_id=plugin_id, activity_type=activity_type, limit=limit ) return { "logs": [ { "id": log.id, "activity_type": log.activity_type, "source": log.source, "details": log.details, "created_at": log.created_at } for log in logs ] } # Serve frontend - MUST be last to not override API routes app.mount("/", StaticFiles(directory="frontend", html=True), name="frontend") if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000)