579 lines
25 KiB
Python
579 lines
25 KiB
Python
"""对话服务：调用 BaoDan Chat API，处理 SSE 流式响应。"""
|
||
import json
|
||
import requests
|
||
from flask import current_app
|
||
|
||
|
||
class ChatService:
|
||
"""智能问答业务逻辑。"""
|
||
|
||
def _get_baodan_conversation_id(self, user_id: str, session_id: str) -> str:
|
||
"""获取调用 BaoDan 时应使用的 conversation_id。
|
||
|
||
BaoDan 只接受它自己返回过的 conversation_id。
|
||
本地新建的 session_id 对 BaoDan 来说不存在，必须传空让它创建新对话。
|
||
"""
|
||
if not session_id:
|
||
return ""
|
||
|
||
try:
|
||
from insurance.models.chat_session import ChatSession
|
||
from insurance.models.chat_record import ChatRecord
|
||
|
||
# 检查本地会话是否存在
|
||
session = ChatSession.query.filter_by(
|
||
user_id=user_id,
|
||
session_id=session_id,
|
||
is_deleted=False,
|
||
).first()
|
||
if not session:
|
||
# 本地无此会话记录，传空让 BaoDan 创建新对话
|
||
return ""
|
||
|
||
# 检查该会话是否有聊天记录（说明之前已经和 BaoDan 建立过对话）
|
||
has_records = ChatRecord.query.filter_by(
|
||
user_id=user_id,
|
||
session_id=session_id,
|
||
).first() is not None
|
||
|
||
if not has_records:
|
||
# 新会话，没有记录，传空让 BaoDan 创建新对话
|
||
return ""
|
||
|
||
# 有记录，说明之前已经和 BaoDan 对话过
|
||
# 优先使用存储的 baodan_conversation_id
|
||
if hasattr(session, 'baodan_conversation_id') and session.baodan_conversation_id:
|
||
return session.baodan_conversation_id
|
||
|
||
# 如果没有存储 baodan_conversation_id，使用本地 session_id
|
||
# （因为 session_id 可能就是 BaoDan 之前返回的 conversation_id）
|
||
return session_id
|
||
except Exception:
|
||
return ""
|
||
|
||
def _finalize_session(self, user_id: str, requested_session_id: str, final_session_id: str, first_message: str) -> str:
|
||
"""确保会话落库，并把本地占位会话 ID 绑定为 BaoDan 返回的真实 ID。"""
|
||
import logging
|
||
|
||
persisted_session_id = final_session_id or requested_session_id
|
||
if not persisted_session_id:
|
||
return ""
|
||
|
||
session_name = first_message[:20].replace("\n", " ")
|
||
if len(first_message) > 20:
|
||
session_name += "..."
|
||
session_name = session_name or "新会话"
|
||
|
||
try:
|
||
from insurance.db.compat import db
|
||
from insurance.models.chat_session import ChatSession
|
||
from insurance.models.chat_record import ChatRecord
|
||
|
||
if requested_session_id:
|
||
local_session = ChatSession.query.filter_by(
|
||
user_id=user_id,
|
||
session_id=requested_session_id,
|
||
is_deleted=False,
|
||
).first()
|
||
else:
|
||
local_session = None
|
||
|
||
final_session = ChatSession.query.filter_by(
|
||
user_id=user_id,
|
||
session_id=persisted_session_id,
|
||
is_deleted=False,
|
||
).first()
|
||
|
||
if local_session and requested_session_id != persisted_session_id:
|
||
if final_session:
|
||
# 目标会话已存在，合并记录
|
||
ChatRecord.query.filter_by(
|
||
user_id=user_id,
|
||
session_id=requested_session_id,
|
||
).update({"session_id": persisted_session_id})
|
||
db.session.delete(local_session)
|
||
else:
|
||
# 目标会话不存在，更新本地会话的 session_id，并同步更新聊天记录
|
||
local_session.session_id = persisted_session_id
|
||
ChatRecord.query.filter_by(
|
||
user_id=user_id,
|
||
session_id=requested_session_id,
|
||
).update({"session_id": persisted_session_id})
|
||
if not local_session.name or local_session.name == "新会话":
|
||
local_session.name = session_name
|
||
elif final_session:
|
||
if not final_session.name or final_session.name == "新会话":
|
||
final_session.name = session_name
|
||
elif not local_session:
|
||
db.session.add(ChatSession(
|
||
session_id=persisted_session_id,
|
||
user_id=user_id,
|
||
name=session_name,
|
||
))
|
||
elif not local_session.name or local_session.name == "新会话":
|
||
local_session.name = session_name
|
||
|
||
# 保存 BaoDan 返回的 conversation_id，用于后续对话保持上下文
|
||
# 只要 BaoDan 返回了 conversation_id，就保存到本地会话
|
||
if final_session_id and final_session_id != requested_session_id:
|
||
# BaoDan 返回了不同于本地 session_id 的 conversation_id，需要保存
|
||
target_session = local_session or final_session
|
||
if not target_session:
|
||
# 可能是新建的会话，重新查询
|
||
target_session = ChatSession.query.filter_by(
|
||
user_id=user_id,
|
||
session_id=persisted_session_id,
|
||
is_deleted=False,
|
||
).first()
|
||
if target_session:
|
||
target_session.baodan_conversation_id = final_session_id
|
||
logging.info(f"保存会话的 BaoDan conversation_id: session_id={persisted_session_id}, baodan_conversation_id={final_session_id}")
|
||
|
||
db.session.commit()
|
||
return persisted_session_id
|
||
except Exception as e:
|
||
logging.exception(f"保存会话失败: {e}")
|
||
try:
|
||
from insurance.db.compat import db
|
||
db.session.rollback()
|
||
except Exception:
|
||
pass
|
||
return persisted_session_id
|
||
|
||
def _save_chat_record(self, user_id: str, session_id: str, role: str, content: str, message_id: str = ""):
|
||
"""保存对话记录到本地数据库。"""
|
||
import logging
|
||
logging.info(f"[SAVE] 开始保存消息: role={role}, session_id={session_id}, user_id={user_id}")
|
||
|
||
from insurance.db.compat import db
|
||
from insurance.models.chat_record import ChatRecord
|
||
|
||
record = ChatRecord(
|
||
user_id=user_id,
|
||
session_id=session_id,
|
||
role=role,
|
||
content=content[:100] + "..." if len(content) > 100 else content,
|
||
message_id=message_id,
|
||
)
|
||
db.session.add(record)
|
||
db.session.commit()
|
||
logging.info(f"[SAVE] 消息保存成功: role={role}, session_id={session_id[:8]}..., record_id={record.id}")
|
||
|
||
def send_message_stream(self, user_id: str, message: str, session_id: str, filters: dict,
|
||
api_token: str = "", base_url: str = ""):
|
||
"""调用 BaoDan Chat API，以 SSE 流式返回结果。"""
|
||
api_key = api_token or ""
|
||
base_url = base_url or "http://localhost:5001"
|
||
|
||
# 注意：用户消息的保存延迟到 message_end 事件中，确保使用正确的 conversation_id
|
||
|
||
baodan_conversation_id = self._get_baodan_conversation_id(user_id, session_id)
|
||
|
||
payload = {
|
||
"inputs": {},
|
||
"query": message,
|
||
"response_mode": "streaming",
|
||
"user": f"user_{user_id}",
|
||
"conversation_id": baodan_conversation_id,
|
||
"files": [],
|
||
}
|
||
|
||
# 如果有筛选条件，通过 inputs 传递给 BaoDan Workflow
|
||
if filters:
|
||
payload["inputs"] = filters
|
||
|
||
headers = {
|
||
"Authorization": f"Bearer {api_key}",
|
||
"Content-Type": "application/json",
|
||
}
|
||
|
||
# 收集完整的助手回复
|
||
full_answer = ""
|
||
final_message_id = ""
|
||
final_session_id = session_id
|
||
done_yielded = False
|
||
|
||
try:
|
||
import logging
|
||
logging.info(f"调用 BaoDan API: {base_url}/v1/chat-messages, conversation_id={baodan_conversation_id}")
|
||
|
||
resp = requests.post(
|
||
f"{base_url}/v1/chat-messages",
|
||
json=payload,
|
||
headers=headers,
|
||
stream=True,
|
||
timeout=120,
|
||
)
|
||
|
||
logging.info(f"BaoDan API 响应状态码: {resp.status_code}")
|
||
|
||
# 检查响应状态码
|
||
if resp.status_code != 200:
|
||
error_text = resp.text[:500] if resp.text else "无响应内容"
|
||
logging.error(f"BaoDan API 返回错误: {resp.status_code} - {error_text}")
|
||
yield json.dumps({
|
||
"type": "error",
|
||
"data": {"message": f"AI 服务返回错误 (HTTP {resp.status_code})"},
|
||
})
|
||
return
|
||
|
||
for line in resp.iter_lines():
|
||
if not line:
|
||
continue
|
||
decoded = line.decode("utf-8")
|
||
if decoded.startswith("data: "):
|
||
event_data = json.loads(decoded[6:])
|
||
event_type = event_data.get("event", "")
|
||
|
||
if event_type == "message":
|
||
# 文本增量
|
||
answer_chunk = event_data.get("answer", "")
|
||
full_answer += answer_chunk
|
||
yield json.dumps({
|
||
"type": "delta",
|
||
"data": answer_chunk,
|
||
})
|
||
elif event_type == "message_end":
|
||
# 回答完成
|
||
metadata = event_data.get("metadata", {})
|
||
retriever = metadata.get("retriever_resources", [])
|
||
final_message_id = event_data.get("message_id", "")
|
||
# 优先使用 BaoDan 返回的 conversation_id，如果没有则使用原始 session_id
|
||
returned_conversation_id = event_data.get("conversation_id", "")
|
||
final_session_id = returned_conversation_id if returned_conversation_id else session_id
|
||
final_session_id = self._finalize_session(user_id, session_id, final_session_id, message)
|
||
# 调试日志：检查 BaoDan 返回的 conversation_id
|
||
import logging
|
||
logging.info(f"BaoDan message_end: conversation_id={returned_conversation_id}, session_id={session_id}, final_session_id={final_session_id}")
|
||
|
||
# 保存用户消息到本地数据库（延迟保存，确保使用正确的 conversation_id）
|
||
logging.info(f"[SAVE] 准备保存用户消息: session_id={final_session_id}, message={message[:50]}...")
|
||
self._save_chat_record(user_id, final_session_id, "user", message)
|
||
logging.info(f"[SAVE] 用户消息保存完成")
|
||
|
||
# 保存助手回复到本地数据库
|
||
if full_answer:
|
||
logging.info(f"[SAVE] 准备保存助手回复: session_id={final_session_id}, answer={full_answer[:50]}...")
|
||
self._save_chat_record(user_id, final_session_id, "assistant", full_answer, final_message_id)
|
||
logging.info(f"[SAVE] 助手回复保存完成")
|
||
|
||
# 发送来源引用
|
||
for ref in retriever:
|
||
yield json.dumps({
|
||
"type": "source",
|
||
"data": {
|
||
"doc_name": ref.get("document_name", ""),
|
||
"chunk": ref.get("content", ""),
|
||
"score": ref.get("score", 0),
|
||
},
|
||
})
|
||
|
||
# 发送完成事件
|
||
yield json.dumps({
|
||
"type": "done",
|
||
"data": {
|
||
"message_id": final_message_id,
|
||
"conversation_id": final_session_id,
|
||
},
|
||
})
|
||
done_yielded = True
|
||
elif event_type == "error":
|
||
yield json.dumps({
|
||
"type": "error",
|
||
"data": {"message": event_data.get("message", "未知错误")},
|
||
})
|
||
|
||
except requests.Timeout:
|
||
yield json.dumps({"type": "error", "data": {"message": "BaoDan API 超时"}})
|
||
except Exception as e:
|
||
import logging
|
||
logging.exception(f"对话流式响应异常: {e}")
|
||
yield json.dumps({"type": "error", "data": {"message": str(e)}})
|
||
finally:
|
||
# 确保前端总能收到 done 事件，防止无限加载
|
||
if not done_yielded:
|
||
import logging
|
||
logging.warning("流式响应结束但未收到 done 事件，发送兜底 done")
|
||
yield json.dumps({
|
||
"type": "done",
|
||
"data": {
|
||
"message_id": final_message_id,
|
||
"conversation_id": final_session_id or session_id,
|
||
},
|
||
})
|
||
|
||
def get_sessions(self, user_id: str, page: int, page_size: int) -> dict:
|
||
"""获取用户会话列表（从本地数据库）。"""
|
||
import logging
|
||
|
||
try:
|
||
from insurance.models.chat_session import ChatSession
|
||
|
||
query = ChatSession.query.filter_by(
|
||
user_id=user_id,
|
||
is_deleted=False,
|
||
).order_by(ChatSession.created_at.desc())
|
||
|
||
total = query.count()
|
||
sessions = query.offset((page - 1) * page_size).limit(page_size).all()
|
||
items = [s.to_dict() for s in sessions]
|
||
|
||
logging.info(f"获取会话列表成功: user_id={user_id}, count={len(items)}")
|
||
return {
|
||
"code": 0,
|
||
"message": "success",
|
||
"data": {
|
||
"data": items,
|
||
"items": items,
|
||
"total": total,
|
||
"page": page,
|
||
"limit": page_size,
|
||
"has_more": (page * page_size) < total,
|
||
},
|
||
}
|
||
except Exception as e:
|
||
logging.exception(f"获取会话列表失败: {e}")
|
||
return {"code": 5001, "message": f"获取会话列表失败: {str(e)}", "data": {"data": [], "items": []}}
|
||
|
||
def create_session(self, user_id: str, session_id: str = "", name: str = "新会话") -> dict:
|
||
"""创建新会话（保存到本地数据库）。"""
|
||
import logging
|
||
import uuid
|
||
|
||
try:
|
||
from insurance.db.compat import db
|
||
from insurance.models.chat_session import ChatSession
|
||
|
||
if not session_id:
|
||
session_id = str(uuid.uuid4())
|
||
|
||
existing = ChatSession.query.filter_by(
|
||
user_id=user_id,
|
||
session_id=session_id,
|
||
is_deleted=False,
|
||
).first()
|
||
if existing:
|
||
return {"code": 0, "message": "success", "data": {"session_id": session_id}}
|
||
|
||
def _persist_session(session_obj: ChatSession) -> None:
|
||
db.session.add(session_obj)
|
||
db.session.commit()
|
||
|
||
session = ChatSession(
|
||
session_id=session_id,
|
||
user_id=user_id,
|
||
name=name,
|
||
)
|
||
|
||
try:
|
||
_persist_session(session)
|
||
logging.info(f"会话已创建: session_id={session_id}, user_id={user_id}")
|
||
except Exception as db_error:
|
||
db.session.rollback()
|
||
logging.warning(f"当前上下文创建会话失败，尝试 app context: {db_error}")
|
||
try:
|
||
from insurance.app import app as flask_app
|
||
with flask_app.app_context():
|
||
from insurance.db.compat import db as ctx_db
|
||
from insurance.models.chat_session import ChatSession as CtxChatSession
|
||
|
||
ctx_session = CtxChatSession(
|
||
session_id=session_id,
|
||
user_id=user_id,
|
||
name=name,
|
||
)
|
||
ctx_db.session.add(ctx_session)
|
||
ctx_db.session.commit()
|
||
logging.info(f"会话已创建（with app context）: session_id={session_id}, user_id={user_id}")
|
||
except Exception as ctx_error:
|
||
logging.exception(f"创建会话失败: {ctx_error}")
|
||
return {"code": 5001, "message": f"创建会话失败: {str(ctx_error)}", "data": None}
|
||
|
||
return {"code": 0, "message": "success", "data": {"session_id": session_id}}
|
||
except Exception as e:
|
||
logging.exception(f"创建会话失败: {e}")
|
||
return {"code": 5001, "message": f"创建会话失败: {str(e)}", "data": None}
|
||
|
||
def delete_session(self, user_id: str, session_id: str) -> dict:
|
||
"""软删除会话（本地数据库）。"""
|
||
try:
|
||
from insurance.db.compat import db
|
||
from insurance.models.chat_session import ChatSession
|
||
|
||
session = ChatSession.query.filter_by(
|
||
session_id=session_id,
|
||
user_id=user_id,
|
||
).first()
|
||
|
||
if session:
|
||
session.is_deleted = True
|
||
db.session.commit()
|
||
import logging
|
||
logging.info(f"会话已删除: session_id={session_id}")
|
||
return {"code": 0, "message": "success", "data": None}
|
||
else:
|
||
return {"code": 404, "message": "会话不存在", "data": None}
|
||
except Exception as e:
|
||
import logging
|
||
logging.error(f"删除会话失败: {e}")
|
||
return {"code": 5001, "message": f"删除会话失败: {str(e)}", "data": None}
|
||
|
||
def get_messages(self, user_id: str, session_id: str) -> dict:
|
||
"""获取会话消息记录（从本地数据库）。"""
|
||
import logging
|
||
logging.info(f"[QUERY] 查询消息: user_id={user_id}, session_id={session_id}")
|
||
try:
|
||
from insurance.models.chat_record import ChatRecord
|
||
|
||
records = ChatRecord.query.filter_by(
|
||
user_id=user_id,
|
||
session_id=session_id,
|
||
).order_by(ChatRecord.created_at.asc(), ChatRecord.id.asc()).all()
|
||
logging.info(f"[QUERY] 查询到 {len(records)} 条记录")
|
||
|
||
# 调试：列出所有该用户的消息
|
||
all_records = ChatRecord.query.filter_by(user_id=user_id).order_by(ChatRecord.id.desc()).limit(5).all()
|
||
for r in all_records:
|
||
logging.info(f"[QUERY] 最近消息: id={r.id}, session_id={r.session_id}, role={r.role}")
|
||
|
||
messages = [record.to_dict() for record in records]
|
||
pairs = []
|
||
i = 0
|
||
while i < len(records):
|
||
record = records[i]
|
||
if record.role == "user":
|
||
assistant = records[i + 1] if i + 1 < len(records) and records[i + 1].role == "assistant" else None
|
||
pairs.append({
|
||
"id": assistant.message_id if assistant else record.message_id or str(record.id),
|
||
"query": record.content,
|
||
"answer": assistant.content if assistant else "",
|
||
"feedback": assistant.rating if assistant else None,
|
||
"sources": [],
|
||
"created_at": str(record.created_at) if record.created_at else None,
|
||
})
|
||
i += 2 if assistant else 1
|
||
else:
|
||
pairs.append({
|
||
"id": record.message_id or str(record.id),
|
||
"query": "",
|
||
"answer": record.content,
|
||
"feedback": record.rating,
|
||
"sources": [],
|
||
"created_at": str(record.created_at) if record.created_at else None,
|
||
})
|
||
i += 1
|
||
|
||
return {
|
||
"code": 0,
|
||
"message": "success",
|
||
"data": {
|
||
"messages": pairs,
|
||
"records": messages,
|
||
"data": pairs,
|
||
},
|
||
}
|
||
except Exception as e:
|
||
import logging
|
||
logging.exception(f"获取本地聊天记录失败: {e}")
|
||
return {"code": 5001, "message": f"获取聊天记录失败: {str(e)}", "data": {"messages": [], "records": []}}
|
||
|
||
def submit_feedback(self, user_id: str, message_id: str, rating: str, comment: str) -> dict:
|
||
"""提交反馈并保存到本地数据库。"""
|
||
import logging
|
||
|
||
try:
|
||
from insurance.db.compat import db
|
||
from insurance.models.chat_record import ChatRecord
|
||
|
||
record = ChatRecord.query.filter_by(
|
||
user_id=user_id,
|
||
message_id=message_id,
|
||
role="assistant",
|
||
).first()
|
||
if record:
|
||
record.rating = rating
|
||
db.session.commit()
|
||
except Exception as e:
|
||
logging.warning(f"保存本地反馈失败: {e}")
|
||
try:
|
||
from insurance.db.compat import db
|
||
db.session.rollback()
|
||
except Exception:
|
||
pass
|
||
|
||
try:
|
||
from flask import current_app
|
||
api_key = current_app.config.get("BAODAN_CHAT_API_KEY", "")
|
||
base_url = current_app.config.get("BAODAN_API_URL", "http://localhost:5001")
|
||
if api_key and message_id:
|
||
requests.post(
|
||
f"{base_url}/v1/messages/{message_id}/feedbacks",
|
||
json={
|
||
"rating": rating,
|
||
"user": f"user_{user_id}",
|
||
"content": comment,
|
||
},
|
||
headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
|
||
timeout=10,
|
||
)
|
||
except Exception as e:
|
||
logging.warning(f"转发反馈到 BaoDan 失败: {e}")
|
||
|
||
return {"code": 0, "message": "success", "data": None}
|
||
|
||
def get_suggestions(self, message: str) -> dict:
|
||
"""基于回答生成推荐追问（调用 LLM）。"""
|
||
from flask import current_app
|
||
api_key = current_app.config.get("BAODAN_CHAT_API_KEY", "")
|
||
base_url = current_app.config.get("BAODAN_API_URL", "http://localhost:5001")
|
||
|
||
prompt = f"基于以下回答，生成 3 个用户可能会追问的相关问题，每行一个：\n\n{message}"
|
||
resp = requests.post(
|
||
f"{base_url}/v1/chat-messages",
|
||
json={
|
||
"inputs": {},
|
||
"query": prompt,
|
||
"response_mode": "blocking",
|
||
"user": "system",
|
||
},
|
||
headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
|
||
timeout=30,
|
||
)
|
||
data = resp.json()
|
||
answer = data.get("answer", "")
|
||
suggestions = [line.strip().lstrip("0123456789.、") for line in answer.split("\n") if line.strip()]
|
||
return {"code": 0, "data": {"suggestions": suggestions[:3]}}
|
||
|
||
def rename_session(self, user_id: str, session_id: str, name: str) -> dict:
|
||
"""重命名会话（本地数据库）。"""
|
||
try:
|
||
from insurance.db.compat import db
|
||
from insurance.models.chat_session import ChatSession
|
||
|
||
session = ChatSession.query.filter_by(
|
||
session_id=session_id,
|
||
user_id=user_id,
|
||
).first()
|
||
|
||
if session:
|
||
session.name = name
|
||
db.session.commit()
|
||
import logging
|
||
logging.info(f"会话已重命名: session_id={session_id}, name={name}")
|
||
return {"code": 0, "message": "success", "data": None}
|
||
else:
|
||
return {"code": 404, "message": "会话不存在", "data": None}
|
||
except Exception as e:
|
||
import logging
|
||
logging.error(f"重命名会话失败: {e}")
|
||
return {"code": 5001, "message": f"重命名失败: {str(e)}", "data": None}
|
||
|
||
def auto_name_session(self, user_id: str, session_id: str, first_message: str) -> dict:
|
||
"""根据首条消息自动命名会话（提取关键词）。"""
|
||
# 简单提取：取前20个字符作为标题
|
||
name = first_message[:20].replace("\n", " ")
|
||
if len(first_message) > 20:
|
||
name += "..."
|
||
|
||
return self.rename_session(user_id, session_id, name)
|