Simon
445 lines
14 KiB
Python
445 lines
14 KiB
Python
# =============================================================================
|
||
# 企微IT智能服务台 — 知识库自动迭代服务
|
||
# =============================================================================
|
||
# 说明：知识库自动迭代核心服务
|
||
# 功能：
|
||
# 1. 分析错误标注的高频问题
|
||
# 2. 查找未命中知识库的会话
|
||
# 3. 生成优化建议
|
||
# 4. 审核通过后应用到知识库
|
||
# 5. 推送审核通知给管理员
|
||
# =============================================================================
|
||
|
||
import json
|
||
import logging
|
||
from datetime import datetime, timedelta
|
||
from typing import Any, Dict, List, Optional
|
||
|
||
import httpx
|
||
from sqlalchemy import select
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
|
||
from app.config import settings
|
||
from app.models.knowledge_base import KnowledgeBase
|
||
from app.models.knowledge_suggestion import KnowledgeSuggestion
|
||
from app.models.conversation import Conversation
|
||
from app.models.conversation_annotation import ConversationAnnotation
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
|
||
class KnowledgeIterationService:
|
||
"""知识库自动迭代服务。
|
||
|
||
分析会话标注和会话数据，生成知识库优化建议，
|
||
支持管理员审核后自动应用到知识库。
|
||
"""
|
||
|
||
def __init__(self):
|
||
"""初始化服务。"""
|
||
# AI 分析 API（复用 Dify）
|
||
self.ai_api_url = settings.dify_wingman_api_url
|
||
self.ai_api_key = settings.dify_wingman_api_key
|
||
self.ai_timeout = settings.dify_wingman_timeout
|
||
|
||
# --------------------------------------------------------------------------
|
||
# 核心方法：分析并生成建议
|
||
# --------------------------------------------------------------------------
|
||
|
||
async def analyze_and_generate_suggestions(
|
||
self,
|
||
db: AsyncSession,
|
||
days: int = 7,
|
||
) -> Dict[str, Any]:
|
||
"""分析并生成知识库优化建议。
|
||
|
||
分析过去N天的标注数据和会话数据，生成优化建议。
|
||
|
||
Args:
|
||
db: 数据库会话
|
||
days: 分析过去N天的数据，默认7天
|
||
|
||
Returns:
|
||
Dict: {
|
||
"annotations_analyzed": int, # 分析的标注数量
|
||
"conversations_analyzed": int, # 分析的会话数量
|
||
"suggestions_generated": int, # 生成的建议数量
|
||
}
|
||
"""
|
||
result = {
|
||
"annotations_analyzed": 0,
|
||
"conversations_analyzed": 0,
|
||
"suggestions_generated": 0,
|
||
}
|
||
|
||
# 1. 分析错误标注的高频问题
|
||
annotation_suggestions = await self._analyze_annotation_data(db, days)
|
||
result["annotations_analyzed"] = annotation_suggestions.get("analyzed_count", 0)
|
||
result["suggestions_generated"] += annotation_suggestions.get(
|
||
"suggestions_count", 0
|
||
)
|
||
|
||
# 2. 分析未命中知识库的会话
|
||
conversation_suggestions = await self._analyze_conversation_data(db, days)
|
||
result["conversations_analyzed"] = conversation_suggestions.get(
|
||
"analyzed_count", 0
|
||
)
|
||
result["suggestions_generated"] += conversation_suggestions.get(
|
||
"suggestions_count", 0
|
||
)
|
||
|
||
logger.info(
|
||
f"知识库迭代分析完成: "
|
||
f"标注={result['annotations_analyzed']}, "
|
||
f"会话={result['conversations_analyzed']}, "
|
||
f"建议={result['suggestions_generated']}"
|
||
)
|
||
|
||
return result
|
||
|
||
async def _analyze_annotation_data(
|
||
self, db: AsyncSession, days: int
|
||
) -> Dict[str, Any]:
|
||
"""分析标注数据，生成优化建议。
|
||
|
||
查找被标记为"无用"的AI回复，分析高频错误原因，
|
||
尝试生成FAQ更新建议。
|
||
|
||
Args:
|
||
db: 数据库会话
|
||
days: 分析过去N天的数据
|
||
|
||
Returns:
|
||
Dict: 分析结果统计
|
||
"""
|
||
since = datetime.now() - timedelta(days=days)
|
||
|
||
# 查询过去N天的无效标注
|
||
stmt = (
|
||
select(ConversationAnnotation)
|
||
.where(ConversationAnnotation.feedback == "useless")
|
||
.where(ConversationAnnotation.created_at >= since)
|
||
)
|
||
result = await db.execute(stmt)
|
||
annotations = result.scalars().all()
|
||
|
||
if not annotations:
|
||
return {"analyzed_count": 0, "suggestions_count": 0}
|
||
|
||
# 按被标注的消息ID分组，统计高频错误
|
||
message_error_counts: Dict[str, int] = {}
|
||
for ann in annotations:
|
||
msg_id = ann.message_id
|
||
message_error_counts[msg_id] = message_error_counts.get(msg_id, 0) + 1
|
||
|
||
# 找出高频错误（被标注3次以上）
|
||
frequent_errors = {
|
||
msg_id: count
|
||
for msg_id, count in message_error_counts.items()
|
||
if count >= 3
|
||
}
|
||
|
||
if not frequent_errors:
|
||
return {"analyzed_count": len(annotations), "suggestions_count": 0}
|
||
|
||
# 调用AI分析错误模式，生成更新建议
|
||
suggestions_count = 0
|
||
for msg_id, error_count in frequent_errors.items():
|
||
# 生成优化建议
|
||
suggestion = await self._generate_update_suggestion(
|
||
db=db,
|
||
source_type="annotation",
|
||
source_data=[msg_id],
|
||
reason=f"该AI回复在过去{days}天内被标记为无用{error_count}次",
|
||
)
|
||
if suggestion:
|
||
db.add(suggestion)
|
||
suggestions_count += 1
|
||
|
||
await db.commit()
|
||
|
||
return {"analyzed_count": len(annotations), "suggestions_count": suggestions_count}
|
||
|
||
async def _analyze_conversation_data(
|
||
self, db: AsyncSession, days: int
|
||
) -> Dict[str, Any]:
|
||
"""分析会话数据，生成新增FAQ建议。
|
||
|
||
查找AI无法解决（转人工）的会话，分析生成新FAQ建议。
|
||
|
||
Args:
|
||
db: 数据库会话
|
||
days: 分析过去N天的数据
|
||
|
||
Returns:
|
||
Dict: 分析结果统计
|
||
"""
|
||
since = datetime.now() - timedelta(days=days)
|
||
|
||
# 查询过去N天的AI未解决会话（转人工的会话）
|
||
stmt = (
|
||
select(Conversation)
|
||
.where(Conversation.created_at >= since)
|
||
.where(Conversation.status.in_(["waiting_agent", "agentServing"]))
|
||
)
|
||
result = await db.execute(stmt)
|
||
conversations = result.scalars().all()
|
||
|
||
if not conversations:
|
||
return {"analyzed_count": 0, "suggestions_count": 0}
|
||
|
||
# 抽样分析（避免一次性处理太多）
|
||
sample_size = min(20, len(conversations))
|
||
sampled = conversations[:sample_size]
|
||
|
||
# 对每个会话进行分析
|
||
suggestions_count = 0
|
||
for conv in sampled:
|
||
# 检查是否已存在类似建议
|
||
existing = await self._check_existing_suggestion(db, conv.id)
|
||
if existing:
|
||
continue
|
||
|
||
# 生成新FAQ建议
|
||
suggestion = await self._generate_new_faq_suggestion(
|
||
db=db,
|
||
source_type="conversation",
|
||
source_data=[conv.id],
|
||
reason=f"会话'{conv.id}'中AI未能解决问题，需人工介入",
|
||
)
|
||
if suggestion:
|
||
db.add(suggestion)
|
||
suggestions_count += 1
|
||
|
||
await db.commit()
|
||
|
||
return {"analyzed_count": len(conversations), "suggestions_count": suggestions_count}
|
||
|
||
# --------------------------------------------------------------------------
|
||
# 辅助方法
|
||
# --------------------------------------------------------------------------
|
||
|
||
async def _generate_update_suggestion(
|
||
self,
|
||
db: AsyncSession,
|
||
source_type: str,
|
||
source_data: List[str],
|
||
reason: str,
|
||
) -> Optional[KnowledgeSuggestion]:
|
||
"""生成知识库更新建议。
|
||
|
||
Args:
|
||
db: 数据库会话
|
||
source_type: 来源类型
|
||
source_data: 来源数据
|
||
reason: 生成理由
|
||
|
||
Returns:
|
||
Optional[KnowledgeSuggestion]: 建议对象
|
||
"""
|
||
# TODO: 调用AI生成具体的更新内容
|
||
# 当前返回示例数据，实际应调用 Dify API
|
||
|
||
return KnowledgeSuggestion(
|
||
suggestion_type="update",
|
||
status="pending",
|
||
title="[待AI生成] 优化建议",
|
||
content="请通过AI分析生成具体的更新内容",
|
||
category="其他",
|
||
tags=[],
|
||
source_type=source_type,
|
||
source_data=source_data,
|
||
reason=reason,
|
||
)
|
||
|
||
async def _generate_new_faq_suggestion(
|
||
self,
|
||
db: AsyncSession,
|
||
source_type: str,
|
||
source_data: List[str],
|
||
reason: str,
|
||
) -> Optional[KnowledgeSuggestion]:
|
||
"""生成新FAQ建议。
|
||
|
||
Args:
|
||
db: 数据库会话
|
||
source_type: 来源类型
|
||
source_data: 来源数据
|
||
reason: 生成理由
|
||
|
||
Returns:
|
||
Optional[KnowledgeSuggestion]: 建议对象
|
||
"""
|
||
# TODO: 调用AI生成具体的FAQ内容
|
||
# 当前返回示例数据，实际应调用 Dify API
|
||
|
||
return KnowledgeSuggestion(
|
||
suggestion_type="new_faq",
|
||
status="pending",
|
||
title="[待AI生成] 新FAQ建议",
|
||
content="请通过AI分析生成具体的问题和答案",
|
||
category="其他",
|
||
tags=[],
|
||
source_type=source_type,
|
||
source_data=source_data,
|
||
reason=reason,
|
||
)
|
||
|
||
async def _check_existing_suggestion(
|
||
self, db: AsyncSession, source_id: str
|
||
) -> bool:
|
||
"""检查是否已存在相关建议。
|
||
|
||
Args:
|
||
db: 数据库会话
|
||
source_id: 来源ID
|
||
|
||
Returns:
|
||
bool: 是否已存在
|
||
"""
|
||
stmt = (
|
||
select(KnowledgeSuggestion)
|
||
.where(KnowledgeSuggestion.status == "pending")
|
||
.where(KnowledgeSuggestion.source_data.contains(source_id))
|
||
)
|
||
result = await db.execute(stmt)
|
||
existing = result.scalars().first()
|
||
return existing is not None
|
||
|
||
# --------------------------------------------------------------------------
|
||
# 审核与应用
|
||
# --------------------------------------------------------------------------
|
||
|
||
async def approve_suggestion(
|
||
self,
|
||
db: AsyncSession,
|
||
suggestion_id: str,
|
||
reviewer_id: str,
|
||
) -> Optional[KnowledgeSuggestion]:
|
||
"""审核通过建议并应用到知识库。
|
||
|
||
Args:
|
||
db: 数据库会话
|
||
suggestion_id: 建议ID
|
||
reviewer_id: 审核人ID
|
||
|
||
Returns:
|
||
Optional[KnowledgeSuggestion]: 更新后的建议对象
|
||
"""
|
||
# 获取建议
|
||
stmt = select(KnowledgeSuggestion).where(
|
||
KnowledgeSuggestion.id == suggestion_id
|
||
)
|
||
result = await db.execute(stmt)
|
||
suggestion = result.scalar_one_or_none()
|
||
|
||
if not suggestion:
|
||
return None
|
||
|
||
# 更新状态
|
||
suggestion.status = "approved"
|
||
suggestion.reviewer_id = reviewer_id
|
||
suggestion.reviewed_at = datetime.now()
|
||
|
||
# 如果是新FAQ或更新，创建对应的知识库条目
|
||
if suggestion.suggestion_type in ("new_faq", "update"):
|
||
kb = KnowledgeBase(
|
||
title=suggestion.title,
|
||
content=suggestion.content,
|
||
category=suggestion.category,
|
||
tags=suggestion.tags,
|
||
)
|
||
db.add(kb)
|
||
suggestion.status = "applied"
|
||
|
||
await db.commit()
|
||
await db.refresh(suggestion)
|
||
|
||
logger.info(f"建议已审核通过并应用: {suggestion_id}")
|
||
return suggestion
|
||
|
||
async def reject_suggestion(
|
||
self,
|
||
db: AsyncSession,
|
||
suggestion_id: str,
|
||
reviewer_id: str,
|
||
reject_reason: str,
|
||
) -> Optional[KnowledgeSuggestion]:
|
||
"""拒绝建议。
|
||
|
||
Args:
|
||
db: 数据库会话
|
||
suggestion_id: 建议ID
|
||
reviewer_id: 审核人ID
|
||
reject_reason: 拒绝理由
|
||
|
||
Returns:
|
||
Optional[KnowledgeSuggestion]: 更新后的建议对象
|
||
"""
|
||
stmt = select(KnowledgeSuggestion).where(
|
||
KnowledgeSuggestion.id == suggestion_id
|
||
)
|
||
result = await db.execute(stmt)
|
||
suggestion = result.scalar_one_or_none()
|
||
|
||
if not suggestion:
|
||
return None
|
||
|
||
suggestion.status = "rejected"
|
||
suggestion.reviewer_id = reviewer_id
|
||
suggestion.reviewed_at = datetime.now()
|
||
suggestion.reject_reason = reject_reason
|
||
|
||
await db.commit()
|
||
await db.refresh(suggestion)
|
||
|
||
logger.info(f"建议已拒绝: {suggestion_id}, 理由: {reject_reason}")
|
||
return suggestion
|
||
|
||
# --------------------------------------------------------------------------
|
||
# 查询统计
|
||
# --------------------------------------------------------------------------
|
||
|
||
async def get_suggestion_stats(self, db: AsyncSession) -> Dict[str, int]:
|
||
"""获取建议统计。
|
||
|
||
Args:
|
||
db: 数据库会话
|
||
|
||
Returns:
|
||
Dict: 统计数据
|
||
"""
|
||
# 总数
|
||
stmt = select(KnowledgeSuggestion)
|
||
result = await db.execute(stmt)
|
||
all_suggestions = result.scalars().all()
|
||
|
||
stats = {
|
||
"total": len(all_suggestions),
|
||
"pending": 0,
|
||
"approved": 0,
|
||
"rejected": 0,
|
||
"applied": 0,
|
||
"new_faq_count": 0,
|
||
"update_count": 0,
|
||
"outdated_count": 0,
|
||
}
|
||
|
||
for s in all_suggestions:
|
||
if s.status in stats:
|
||
stats[s.status] += 1
|
||
if s.suggestion_type == "new_faq":
|
||
stats["new_faq_count"] += 1
|
||
elif s.suggestion_type == "update":
|
||
stats["update_count"] += 1
|
||
elif s.suggestion_type == "outdated":
|
||
stats["outdated_count"] += 1
|
||
|
||
return stats
|
||
|
||
|
||
# 依赖注入函数
|
||
async def dep_knowledge_iteration_service() -> KnowledgeIterationService:
|
||
"""获取知识库迭代服务实例。"""
|
||
return KnowledgeIterationService()
|