This commit is contained in:
Ubuntu
2026-07-03 16:58:28 +08:00
commit 32b43f85bd
6240 changed files with 1987678 additions and 0 deletions
View File
+154
View File
@@ -0,0 +1,154 @@
"""
AI 客服核心逻辑 - 基于 LangGraph
"""
from typing import TypedDict, Annotated, Sequence
import operator
from langchain_core.messages import BaseMessage, HumanMessage, AIMessage, SystemMessage
from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph, END
from langgraph.checkpoint.memory import MemorySaver
from config import LLM_API_KEY, LLM_BASE_URL, LLM_MODEL, SYSTEM_PROMPT
from knowledge import get_knowledge_base
# 定义状态类型
class ChatState(TypedDict):
"""对话状态"""
messages: Annotated[Sequence[BaseMessage], operator.add] # 消息历史
context: str # 检索到的知识上下文
session_id: str # 会话ID
class AIChatbot:
"""AI 客服机器人"""
def __init__(self):
# 初始化 LLM
self.llm = ChatOpenAI(
model=LLM_MODEL,
api_key=LLM_API_KEY,
base_url=LLM_BASE_URL,
temperature=0.7,
max_tokens=1000
)
# 获取知识库
self.knowledge_base = get_knowledge_base()
# 构建工作流
self.workflow = self._build_workflow()
def _retrieve_knowledge(self, state: ChatState) -> ChatState:
"""检索相关知识"""
# 获取最后一条用户消息
last_message = state["messages"][-1]
if not isinstance(last_message, HumanMessage):
return state
query = last_message.content
# 从知识库检索
docs = self.knowledge_base.search(query)
# 构建上下文
if docs:
context = "\n\n".join([f"[知识库内容 {i+1}]\n{doc.page_content}"
for i, doc in enumerate(docs)])
else:
context = "【知识库中没有找到相关信息】"
return {"context": context, "messages": state["messages"], "session_id": state["session_id"]}
def _generate_response(self, state: ChatState) -> ChatState:
"""生成回答"""
# 构建系统提示
system_prompt = f"""{SYSTEM_PROMPT}
【知识库信息】
{state['context']}
请基于以上知识库信息回答用户问题。如果知识库中没有相关信息,请诚实地告诉用户你无法回答。
"""
# 构建消息列表
messages = [SystemMessage(content=system_prompt)] + list(state["messages"])
# 调用 LLM
response = self.llm.invoke(messages)
# 返回新的消息(会自动添加到历史)
return {"messages": [response], "context": state["context"], "session_id": state["session_id"]}
def _build_workflow(self) -> StateGraph:
"""构建 LangGraph 工作流"""
# 创建工作流
workflow = StateGraph(ChatState)
# 添加节点
workflow.add_node("retrieve", self._retrieve_knowledge)
workflow.add_node("generate", self._generate_response)
# 添加边
workflow.set_entry_point("retrieve")
workflow.add_edge("retrieve", "generate")
workflow.add_edge("generate", END)
# 编译(添加内存检查点)
memory = MemorySaver()
return workflow.compile(checkpointer=memory)
async def chat(self, message: str, session_id: str) -> str:
"""
处理用户消息
Args:
message: 用户消息
session_id: 会话ID(用于区分不同用户)
Returns:
AI 回复
"""
# 构建配置
config = {"configurable": {"thread_id": session_id}}
# 运行工作流
result = await self.workflow.ainvoke(
{
"messages": [HumanMessage(content=message)],
"context": "",
"session_id": session_id
},
config
)
# 返回最后一条 AI 消息
last_message = result["messages"][-1]
if isinstance(last_message, AIMessage):
return last_message.content
return str(last_message)
def get_history(self, session_id: str) -> list:
"""获取对话历史"""
config = {"configurable": {"thread_id": session_id}}
# 从 checkpointer 获取状态
state = self.workflow.get_state(config)
if state and "messages" in state.values:
return [
{"role": "user" if isinstance(m, HumanMessage) else "assistant",
"content": m.content}
for m in state.values["messages"]
]
return []
# 全局客服实例
_chatbot = None
def get_chatbot() -> AIChatbot:
"""获取客服单例"""
global _chatbot
if _chatbot is None:
_chatbot = AIChatbot()
return _chatbot
+186
View File
@@ -0,0 +1,186 @@
"""
混合模式客服系统 - 支持业务知识+通用知识+实时工具
"""
from typing import TypedDict, Literal
from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
from langchain_openai import ChatOpenAI
from langgraph.graph import StateGraph, END
from langgraph.checkpoint.memory import MemorySaver
from config import LLM_API_KEY, LLM_BASE_URL, LLM_MODEL, SYSTEM_PROMPT
from knowledge import get_knowledge_base
class HybridState(TypedDict):
"""混合模式状态"""
messages: list
intent: Literal["medical", "general", "realtime", "greeting"]
context: str
tool_result: str
session_id: str
class HybridChatbot:
"""混合客服:垂直领域 + 通用知识 + 实时工具"""
def __init__(self):
self.llm = ChatOpenAI(
model=LLM_MODEL,
api_key=LLM_API_KEY,
base_url=LLM_BASE_URL,
temperature=0.7
)
self.knowledge_base = get_knowledge_base()
self.workflow = self._build_workflow()
def _classify_intent(self, state: HybridState) -> HybridState:
"""意图识别 - 判断问题类型"""
query = state["messages"][-1].content
# 用LLM快速判断意图(也可以用关键词规则)
prompt = f"""判断用户意图,只能返回以下之一:
- medical: 医疗/健康相关问题
- general: 通用知识(历史、科学、生活常识等)
- realtime: 需要实时数据(天气、股价、新闻等)
- greeting: 问候/闲聊
用户问题:{query}
意图:"""
response = self.llm.invoke([HumanMessage(content=prompt)])
intent = response.content.strip().lower()
# 归一化
valid_intents = ["medical", "general", "realtime", "greeting"]
intent = intent if intent in valid_intents else "general"
print(f"🎯 意图识别: {query} -> {intent}")
return {"intent": intent, "messages": state["messages"], "session_id": state["session_id"]}
def _route_by_intent(self, state: HybridState) -> str:
"""根据意图路由到不同节点"""
intent = state.get("intent", "general")
routing_map = {
"medical": "retrieve_knowledge", # 查医疗知识库
"general": "general_answer", # 直接问大模型
"realtime": "call_tool", # 调用实时工具
"greeting": "general_answer" # 闲聊也走通用
}
return routing_map.get(intent, "general_answer")
def _retrieve_medical(self, state: HybridState) -> HybridState:
"""检索医疗知识库"""
query = state["messages"][-1].content
docs = self.knowledge_base.search(query)
if docs:
context = "\n".join([doc.page_content for doc in docs])
return {"context": context, "messages": state["messages"],
"intent": state["intent"], "session_id": state["session_id"]}
else:
# 医疗问题但知识库没有 → 转人工
return {"context": "【无相关医疗知识,需转人工】",
"messages": state["messages"],
"intent": state["intent"], "session_id": state["session_id"]}
def _call_realtime_tool(self, state: HybridState) -> HybridState:
"""调用实时工具(MCP/Function Call)"""
query = state["messages"][-1].content
# 示例:天气查询(实际可用 MCP/天气API)
if "天气" in query:
# 这里可以调用 MCP 或天气API
# result = call_mcp("weather", location="北京")
tool_result = "【实时天气工具】:北京今天晴,25°C,适合出行"
elif "股价" in query or "股票" in query:
tool_result = "【实时股价工具】:需要调用股票API获取实时数据"
else:
tool_result = "【无可用工具】"
return {"tool_result": tool_result, "messages": state["messages"],
"intent": state["intent"], "session_id": state["session_id"]}
def _generate_answer(self, state: HybridState) -> HybridState:
"""生成最终回答"""
intent = state["intent"]
query = state["messages"][-1].content
if intent == "medical":
# 医疗问题:基于知识库回答
if "无相关医疗知识" in state.get("context", ""):
response = "抱歉,这个问题我暂时无法回答,为您转接专业医生..."
else:
system_msg = f"你是医疗助手,基于以下知识回答:\n{state['context']}"
messages = [SystemMessage(content=system_msg)] + state["messages"]
response = self.llm.invoke(messages).content
elif intent == "realtime":
# 实时信息:基于工具结果回答
system_msg = f"基于以下实时信息回答用户:\n{state.get('tool_result', '')}"
messages = [SystemMessage(content=system_msg)] + state["messages"]
response = self.llm.invoke(messages).content
else: # general / greeting
# 通用问题:直接回答
system_msg = "你是友好的助手,回答用户的通用问题。"
messages = [SystemMessage(content=system_msg)] + state["messages"]
response = self.llm.invoke(messages).content
return {"messages": state["messages"] + [AIMessage(content=response)],
"intent": intent, "session_id": state["session_id"]}
def _build_workflow(self):
"""构建工作流"""
workflow = StateGraph(HybridState)
# 添加节点
workflow.add_node("classify", self._classify_intent)
workflow.add_node("retrieve_knowledge", self._retrieve_medical)
workflow.add_node("call_tool", self._call_realtime_tool)
workflow.add_node("general_answer", self._generate_answer)
workflow.add_node("generate", self._generate_answer)
# 条件路由
workflow.set_entry_point("classify")
workflow.add_conditional_edges(
"classify",
self._route_by_intent,
{
"retrieve_knowledge": "retrieve_knowledge",
"call_tool": "call_tool",
"general_answer": "general_answer"
}
)
# 汇聚到生成节点
workflow.add_edge("retrieve_knowledge", "generate")
workflow.add_edge("call_tool", "generate")
workflow.add_edge("generate", END)
workflow.add_edge("general_answer", END)
return workflow.compile(checkpointer=MemorySaver())
async def chat(self, message: str, session_id: str) -> str:
"""处理消息"""
config = {"configurable": {"thread_id": session_id}}
result = await self.workflow.ainvoke(
{"messages": [HumanMessage(content=message)],
"intent": "general",
"context": "",
"tool_result": "",
"session_id": session_id},
config
)
return result["messages"][-1].content
# 单例
_hybrid_chatbot = None
def get_hybrid_chatbot():
global _hybrid_chatbot
if _hybrid_chatbot is None:
_hybrid_chatbot = HybridChatbot()
return _hybrid_chatbot
+49
View File
@@ -0,0 +1,49 @@
"""
AI 客服系统配置
"""
import os
from pathlib import Path
# 项目根目录
BASE_DIR = Path(__file__).parent.parent
# API 配置
# 使用 DeepSeek API(推荐,便宜好用)
LLM_API_KEY = os.getenv("DEEPSEEK_API_KEY", "sk-8cb88f614b5b4def882d0ac46025cdcc")
LLM_BASE_URL = os.getenv("LLM_BASE_URL", "https://api.deepseek.com")
LLM_MODEL = os.getenv("LLM_MODEL", "deepseek-chat")
# 也可以使用其他兼容 OpenAI 的 API
# LLM_BASE_URL = "https://api.openai.com"
# LLM_MODEL = "gpt-3.5-turbo"
# 服务配置
HOST = "0.0.0.0"
PORT = 8890
# 知识库配置
KNOWLEDGE_DIR = BASE_DIR / "knowledge_base"
CHROMA_DB_DIR = BASE_DIR / "data" / "chroma_db"
# 向量模型(使用 HuggingFace 免费模型,本地 CPU 运行)
# 使用 BAAI/bge-small-zh-v1.5 轻量级中文模型,无需 API Key
# 检索配置
RETRIEVAL_TOP_K = 3 # 检索 top-k 个相关文档
CHUNK_SIZE = 500 # 文档分块大小
CHUNK_OVERLAP = 50 # 分块重叠大小
# 客服人设
SYSTEM_PROMPT = """你是「小助手」AI客服,专门为用户提供友好、专业的咨询服务。
【角色设定】
- 你是某公司的智能客服助手
- 你的回答应该亲切、简洁、有帮助
- 如果不确定答案,请诚实地告诉用户你会转接人工客服
【回答原则】
1. 基于提供的知识库内容回答
2. 如果知识库中没有相关信息,请说:"抱歉,这个问题我暂时无法回答,为您转接人工客服..."
3. 不要编造答案
4. 保持礼貌和耐心
"""
+168
View File
@@ -0,0 +1,168 @@
"""
知识库管理模块 - 使用 BAAI/bge-small-zh-v1.5 中文嵌入模型(本地离线版)
"""
import os
from pathlib import Path
from typing import List
from langchain_chroma import Chroma
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import TextLoader
from langchain_core.documents import Document
from config import (
KNOWLEDGE_DIR, CHROMA_DB_DIR,
CHUNK_SIZE, CHUNK_OVERLAP,
RETRIEVAL_TOP_K
)
class KnowledgeBase:
"""知识库管理类 - 基于本地 BGE 中文嵌入模型"""
def __init__(self):
self.db_dir = str(CHROMA_DB_DIR)
self.collection_name = "customer_service_kb"
# 从本地加载 BGE 模型
print("🔧 正在加载本地 BGE 中文嵌入模型...")
# 直接使用 sentence_transformers 加载本地模型
from sentence_transformers import SentenceTransformer
# 本地模型路径
local_model_path = '/home/ubuntu/.cache/huggingface/models--BAAI--bge-small-zh-v1.5/snapshots/'
# 找到具体的 snapshot 目录
if os.path.exists(local_model_path):
snapshots = os.listdir(local_model_path)
if snapshots:
model_path = os.path.join(local_model_path, snapshots[0])
else:
model_path = 'BAAI/bge-small-zh-v1.5' # fallback
else:
model_path = 'BAAI/bge-small-zh-v1.5'
print(f" 模型路径: {model_path}")
# 加载模型
self.model = SentenceTransformer(model_path, device='cpu')
# 创建自定义 Embeddings 类
from langchain_core.embeddings import Embeddings
class LocalBGEEmbeddings(Embeddings):
def __init__(self, model):
self.model = model
def embed_documents(self, texts: List[str]) -> List[List[float]]:
"""嵌入文档"""
embeddings = self.model.encode(texts, normalize_embeddings=True)
return embeddings.tolist()
def embed_query(self, text: str) -> List[float]:
"""嵌入查询"""
embedding = self.model.encode(text, normalize_embeddings=True)
return embedding.tolist()
self.embeddings = LocalBGEEmbeddings(self.model)
print("✅ BGE 模型加载完成")
# 初始化或加载向量数据库
self.vectorstore = self._load_or_create_db()
def _load_or_create_db(self) -> Chroma:
"""加载或创建向量数据库"""
if os.path.exists(self.db_dir) and os.listdir(self.db_dir):
print(f"📚 加载已有知识库: {self.db_dir}")
return Chroma(
collection_name=self.collection_name,
embedding_function=self.embeddings,
persist_directory=self.db_dir
)
else:
print(f"🆕 创建新知识库: {self.db_dir}")
os.makedirs(self.db_dir, exist_ok=True)
return Chroma(
collection_name=self.collection_name,
embedding_function=self.embeddings,
persist_directory=self.db_dir
)
def load_documents(self, directory: str = None) -> List[Document]:
"""从目录加载所有文档"""
directory = directory or str(KNOWLEDGE_DIR)
documents = []
if not os.path.exists(directory):
print(f"⚠️ 目录不存在: {directory}")
return documents
for file_path in Path(directory).glob("*"):
if file_path.suffix.lower() == ".txt":
loader = TextLoader(str(file_path), encoding="utf-8")
documents.extend(loader.load())
print(f"✅ 加载 TXT: {file_path.name}")
elif file_path.suffix.lower() == ".md":
loader = TextLoader(str(file_path), encoding="utf-8")
documents.extend(loader.load())
print(f"✅ 加载 MD: {file_path.name}")
return documents
def add_documents(self, documents: List[Document]):
"""添加文档到知识库"""
if not documents:
print("⚠️ 没有文档需要添加")
return
# 文本分块
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=CHUNK_SIZE,
chunk_overlap=CHUNK_OVERLAP,
separators=["\n\n", "\n", "。", ",", " ", ""]
)
chunks = text_splitter.split_documents(documents)
print(f"📄 文档分块: {len(documents)} 个文档 → {len(chunks)} 个片段")
# 添加到向量数据库
self.vectorstore.add_documents(chunks)
print(f"✅ 已添加到知识库")
def search(self, query: str, k: int = None) -> List[Document]:
"""语义搜索相关知识"""
k = k or RETRIEVAL_TOP_K
results = self.vectorstore.similarity_search(query, k=k)
return results
def get_retriever(self):
"""获取检索器(用于 LangChain)"""
return self.vectorstore.as_retriever(search_kwargs={"k": RETRIEVAL_TOP_K})
def init_knowledge_base():
"""初始化知识库(首次运行时使用)"""
print("🔧 初始化知识库...")
kb = KnowledgeBase()
# 加载知识库目录中的文档
documents = kb.load_documents()
if documents:
kb.add_documents(documents)
print(f"✅ 知识库初始化完成,共 {len(documents)} 个文档")
else:
print("⚠️ 没有找到文档,请在 knowledge_base/ 目录添加文档后重新运行")
return kb
# 全局知识库实例(单例模式)
_knowledge_base = None
def get_knowledge_base() -> KnowledgeBase:
"""获取知识库单例"""
global _knowledge_base
if _knowledge_base is None:
_knowledge_base = KnowledgeBase()
return _knowledge_base
+164
View File
@@ -0,0 +1,164 @@
"""
FastAPI 主服务 - AI 客服系统
"""
import os
import sys
import uuid
from pathlib import Path
from fastapi import FastAPI, Request, UploadFile, File
from fastapi.responses import HTMLResponse
from fastapi.staticfiles import StaticFiles
from fastapi.templating import Jinja2Templates
from pydantic import BaseModel
import uvicorn
# 确保可以导入 app 模块
sys.path.insert(0, str(Path(__file__).parent))
from config import HOST, PORT, BASE_DIR
from chatbot import get_chatbot
from knowledge import init_knowledge_base, get_knowledge_base
# 创建 FastAPI 应用
app = FastAPI(
title="AI 客服系统",
description="基于 LangChain + LangGraph 的智能客服",
version="1.0.0"
)
# 静态文件和模板
app.mount("/static", StaticFiles(directory=str(BASE_DIR / "static")), name="static")
templates = Jinja2Templates(directory=str(BASE_DIR / "templates"))
# 修复 Jinja2 模板缓存问题
templates.env.cache.clear() if hasattr(templates.env, 'cache') and hasattr(templates.env.cache, 'clear') else None
# 数据模型
class ChatRequest(BaseModel):
message: str
session_id: str = None
class ChatResponse(BaseModel):
response: str
session_id: str
# 路由
@app.get("/", response_class=HTMLResponse)
async def index(request: Request):
"""聊天界面"""
# 生成新会话ID
session_id = str(uuid.uuid4())[:8]
# 直接读取 HTML 文件
html_path = BASE_DIR / "templates" / "index.html"
with open(html_path, "r", encoding="utf-8") as f:
html_content = f.read()
# 替换 session_id
html_content = html_content.replace('{{ session_id }}', session_id)
return HTMLResponse(content=html_content)
@app.post("/chat", response_model=ChatResponse)
async def chat(request: ChatRequest):
"""发送消息"""
chatbot = get_chatbot()
# 如果没有 session_id,生成一个
session_id = request.session_id or str(uuid.uuid4())[:8]
# 获取回复
response = await chatbot.chat(request.message, session_id)
return ChatResponse(response=response, session_id=session_id)
@app.get("/history/{session_id}")
async def get_history(session_id: str):
"""获取对话历史"""
chatbot = get_chatbot()
history = chatbot.get_history(session_id)
return {"session_id": session_id, "history": history}
@app.post("/upload")
async def upload_file(file: UploadFile = File(...)):
"""上传知识库文档"""
from config import KNOWLEDGE_DIR
from knowledge import KnowledgeBase
from langchain.schema import Document
# 保存文件
file_path = KNOWLEDGE_DIR / file.filename
with open(file_path, "wb") as f:
content = await file.read()
f.write(content)
# 加载并添加到知识库
kb = get_knowledge_base()
# 简单文本加载
if file.filename.endswith(".txt") or file.filename.endswith(".md"):
with open(file_path, "r", encoding="utf-8") as f:
text = f.read()
doc = Document(page_content=text, metadata={"source": file.filename})
kb.add_documents([doc])
return {"message": f"✅ 已上传并添加到知识库: {file.filename}"}
return {"message": f"✅ 已上传: {file.filename},请重启服务加载"}
@app.get("/health")
async def health_check():
"""健康检查"""
return {"status": "ok", "service": "ai-chatbot"}
@app.on_event("startup")
async def startup_event():
"""启动时初始化"""
print("=" * 60)
print("🤖 AI 客服系统启动中...")
print("=" * 60)
# 检查 API Key
from config import LLM_API_KEY
if LLM_API_KEY == "your-deepseek-api-key-here":
print("⚠️ 警告: 请在 app/config.py 中设置 DEEPSEEK_API_KEY")
print(" 或者设置环境变量: export DEEPSEEK_API_KEY=your-key")
else:
print("✅ API Key 已配置")
# 初始化知识库
print("\n📚 初始化知识库...")
try:
kb = get_knowledge_base()
# 尝试加载已有文档
from pathlib import Path
from config import KNOWLEDGE_DIR
if KNOWLEDGE_DIR.exists():
docs = list(KNOWLEDGE_DIR.glob("*"))
if docs:
print(f" 发现 {len(docs)} 个文档文件")
else:
print(" 知识库目录为空,请在 knowledge_base/ 添加文档")
except Exception as e:
print(f" ⚠️ 知识库初始化失败: {e}")
print("\n🚀 服务已启动!")
print(f" 访问: http://{HOST}:{PORT}")
print("=" * 60)
if __name__ == "__main__":
# 开发模式运行
uvicorn.run(
"main:app",
host=HOST,
port=PORT,
reload=True,
log_level="info"
)