union-py-app-stream-chat 1.0.0

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "union-py-app-stream-chat",
+  "version": "1.0.0",
+  "description": "Source package for the union operations stream chat Python app.",
+  "license": "UNLICENSED",
+  "private": false,
+  "files": [
+    "src",
+    "knowledge",
+    "trainingDocs",
+    "config/config.example.yaml",
+    "main.py",
+    "requirements.txt",
+    "pyproject.toml",
+    "README.md",
+    "tests"
+  ],
+  "scripts": {
+    "pack:check": "npm pack --dry-run"
+  }
+}

package/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "glm-ops-assistant"
+version = "1.0.0"
+description = "运维平台运行表现智能助手 - 基于 GLM 大模型"
+requires-python = ">=3.9"
+dependencies = [
+    "fastapi>=0.110.0",
+    "uvicorn[standard]>=0.29.0",
+    "sse-starlette>=2.0.0",
+    "pydantic>=2.6.0",
+    "pyyaml>=6.0.1",
+    "zhipuai>=2.1.0",
+    "httpx>=0.23.0",
+    "sniffio>=1.3.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["src*", "config*"]

package/requirements.txt

@@ -0,0 +1,11 @@
+fastapi>=0.110.0
+uvicorn[standard]>=0.29.0
+sse-starlette>=2.0.0
+pydantic>=2.6.0
+pyyaml>=6.0.1
+zhipuai>=2.1.0
+httpx>=0.23.0
+sniffio>=1.3.0
+chromadb>=0.5.0
+
+zai

package/src/api/routes.py

@@ -0,0 +1,34 @@
+import json
+from fastapi import APIRouter
+from sse_starlette.sse import EventSourceResponse, ServerSentEvent
+
+from src.models.schemas import ChatRequest
+from src.manager.toolcall_manager import ToolCallManager
+
+router = APIRouter()
+
+
+@router.post("/chat/stream")
+def chat_stream_endpoint(request: ChatRequest):
+    """
+    流式对话接口（SSE）
+    使用工具调用大模型
+    - 接收用户问题
+    - 逐块返回生成的内容
+    """
+    manager = ToolCallManager()
+
+    def event_generator():
+        for chunk in manager.tool_call_stream(request.session_id, request.question):
+            yield ServerSentEvent(
+                event="message",
+                data=json.dumps(chunk, ensure_ascii=False),
+            )
+
+        # SSE 结束标记
+        yield ServerSentEvent(
+            event="done",
+            data=json.dumps({"session_id": request.session_id, "finish_reason": "done"}, ensure_ascii=False),
+        )
+
+    return EventSourceResponse(event_generator())

package/src/core/config_loader.py

@@ -0,0 +1,99 @@
+import os
+import yaml
+from typing import Any, Dict
+
+
+class ConfigLoader:
+    """配置加载器，支持从YAML文件加载配置，并可通过环境变量覆盖。"""
+
+    _instance = None
+    _config = None
+
+    def __new__(cls, *args, **kwargs):
+        if not cls._instance:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self, config_path: str = None):
+        if self._config is not None:
+            return
+
+        if config_path is None:
+            base_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+            config_path = os.path.join(base_dir, "config", "config.yaml")
+
+        self._config_path = config_path
+        self._config = self._load_yaml()
+        self._override_from_env()
+
+    def _load_yaml(self) -> Dict[str, Any]:
+        with open(self._config_path, "r", encoding="utf-8") as f:
+            return yaml.safe_load(f)
+
+    def _override_from_env(self):
+        """通过环境变量覆盖配置，支持 LLM_API_KEY, LLM_MODEL, LLM_BASE_URL 等。"""
+        env_mappings = {
+            "LLM_API_KEY": ["llm", "api_key"],
+            "LLM_MODEL": ["llm", "model"],
+            "LLM_BASE_URL": ["llm", "base_url"],
+            "LLM_MAX_TOKENS": ["llm", "max_tokens"],
+            "LLM_TEMPERATURE": ["llm", "temperature"],
+            "SESSION_TTL": ["session", "ttl_seconds"],
+            "SESSION_MAX_HISTORY": ["session", "max_history"],
+        }
+
+        for env_var, path in env_mappings.items():
+            value = os.environ.get(env_var)
+            if value is not None:
+                # 尝试数字转换
+                try:
+                    if "." in value:
+                        value = float(value)
+                    else:
+                        value = int(value)
+                except ValueError:
+                    pass
+                self._set_nested_value(self._config, path, value)
+
+    def _set_nested_value(self, config: Dict, path: list, value: Any):
+        current = config
+        for key in path[:-1]:
+            current = current.setdefault(key, {})
+        current[path[-1]] = value
+
+    def get(self, *keys: str, default: Any = None) -> Any:
+        current = self._config
+        for key in keys:
+            if isinstance(current, dict) and key in current:
+                current = current[key]
+            else:
+                return default
+        return current
+
+    @property
+    def llm(self) -> Dict[str, Any]:
+        return self._config.get("llm", {})
+
+    @property
+    def system(self) -> Dict[str, Any]:
+        return self._config.get("system", {})
+
+    @property
+    def filter_config(self) -> Dict[str, Any]:
+        return self._config.get("filter", {})
+
+    @property
+    def session(self) -> Dict[str, Any]:
+        return self._config.get("session", {})
+
+    @property
+    def tools(self) -> Dict[str, Any]:
+        return self._config.get("tools", {})
+
+    @property
+    def raw(self) -> Dict[str, Any]:
+        return self._config
+
+
+# 全局配置实例
+config = ConfigLoader()

package/src/manager/toolcall_manager.py

@@ -0,0 +1,12 @@
+"""使用官方的sdk调用模型，整合工具调用能力"""
+from src.utils.function_utils import tools
+from src.service.chat_service import chat_service
+
+
+class ToolCallManager:
+    def __init__(self):
+        self._chat_service = chat_service
+
+    def tool_call_stream(self, session_id: str, question: str):
+        """调用service层的工具调用方法，传入自定义的tools，格式化返回流式结果"""
+        yield from self._chat_service.tool_call_stream(session_id, question, tools)

package/src/models/schemas.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel, Field
+
+
+class ChatRequest(BaseModel):
+    """聊天请求模型"""
+    session_id: str = Field(..., description="会话ID，用于多轮对话上下文")
+    question: str = Field(..., min_length=1, max_length=4096, description="用户问题")

package/src/service/chat_service.py

@@ -0,0 +1,245 @@
+import threading
+import time
+from typing import Dict, Generator, List
+
+from zai import ZhipuAiClient
+
+from src.core.config_loader import config
+from src.utils.function_utils import call_function
+from src.service.rag_service import RagService
+
+
+TOOL_ROUTING_PROMPT = """
+你正在处理网络支付清算平台联合运维客服问题。选择工具前先识别用户真实业务场景：
+1. 提到变更、投产、升级、发布、回滚、灾备、演练、通知、报备、关闭渠道，优先判断为生产变更，使用 evaluate_change_strategy。
+2. 提到系统成功率、业务成功率、失败笔数、耗时、请求量、带宽、异常交易、降低流量、暂停交易、恢复，优先判断为生产运行，使用 evaluate_operation_scene。
+3. 提到轻微/一般/严重故障、故障级别、异常交易笔数、持续时间、定级，使用 evaluate_fault_grade；只问账务调整时限时使用 get_fault_aftercare。
+4. 提到银行/支付机构/成员单位类别、大型/中型/小型单位，使用 classify_member_unit。
+5. 提到制度概念、业务范围、恢复策略、周期评价等解释类问题，使用 get_ops_guidance。
+6. 用户未提供必要指标时，不要编造数值；先说明缺少哪些指标，再给出可确定的规则和下一步需要补充的信息。
+工具返回结果是业务依据。最终回答应结合用户原问题解释结论、触发依据、建议动作，并明确引用《网络支付清算平台联合运维运行实践指引V1.0》。
+""".strip()
+
+
+RAG_PROMPT = """
+请优先依据【知识库检索结果】回答用户问题。
+如果知识库没有明确依据，请说明缺少依据，不要编造规则。
+涉及阈值时保留单位、比较符和适用对象；涉及生产操作时只给建议，不自动执行。
+
+【知识库检索结果】
+{context}
+
+【用户问题】
+{question}
+""".strip()
+
+
+class ChatService:
+    """
+    聊天服务层
+    整合工具调用流式 LLM + 业务过滤
+    """
+
+    def __init__(self):
+        # ---- 过滤配置 ----
+        self._filter_enabled = config.filter_config.get("enabled", True)
+        self._allowed_keywords = config.filter_config.get("allowed_keywords", [])
+        self._rejection_message = config.filter_config.get(
+            "rejection_message",
+            "抱歉，我只能回答与系统运行表现相关的问题。"
+        )
+
+        # ---- LLM 配置 ----
+        llm_cfg = config.llm
+        self._client = ZhipuAiClient(
+            api_key=llm_cfg.get("api_key"),
+            base_url=llm_cfg.get("base_url"),
+        )
+        self._model = llm_cfg.get("model", "glm-4-flash")
+        self._max_tokens = llm_cfg.get("max_tokens", 4096)
+        self._temperature = llm_cfg.get("temperature", 0.7)
+        self._top_p = llm_cfg.get("top_p", 0.9)
+        self._system_prompt = config.system.get("system_prompt", "")
+        self._rag = RagService()
+
+        # ---- 对话上下文 ----
+        self._sessions: Dict[str, Dict] = {}
+        self._max_history = config.session.get("max_history", 20)
+        self._ttl = config.session.get("ttl_seconds", 3600)
+        self._lock = threading.Lock()
+
+    # ========== 过滤 ==========
+
+    def _check_question_valid(self, question: str) -> bool:
+        if not self._filter_enabled or not self._allowed_keywords:
+            return True
+        lower_question = question.lower()
+        return any(k.lower() in lower_question for k in self._allowed_keywords)
+
+    # ========== 对话上下文 ==========
+
+    def _cleanup_expired(self):
+        now = time.time()
+        expired = [sid for sid, s in self._sessions.items() if now - s["last_active"] > self._ttl]
+        for sid in expired:
+            del self._sessions[sid]
+
+    def _ensure_session(self, session_id: str):
+        if session_id not in self._sessions:
+            self._sessions[session_id] = {
+                "messages": [],
+                "created_at": time.time(),
+                "last_active": time.time(),
+            }
+
+    def _get_history(self, session_id: str) -> List[Dict[str, str]]:
+        with self._lock:
+            self._cleanup_expired()
+            self._ensure_session(session_id)
+            return list(self._sessions[session_id]["messages"])
+
+    def _append_exchange(self, session_id: str, user_question: str, assistant_answer: str):
+        with self._lock:
+            self._ensure_session(session_id)
+            session = self._sessions[session_id]
+            session["messages"].extend([
+                {"role": "user", "content": user_question},
+                {"role": "assistant", "content": assistant_answer},
+            ])
+            session["last_active"] = time.time()
+            max_messages = self._max_history * 2
+            if len(session["messages"]) > max_messages:
+                session["messages"] = session["messages"][-max_messages:]
+
+    # ========== LLM ==========
+
+    def _build_messages(
+        self,
+        session_id: str,
+        user_question: str,
+        rag_context: str = "",
+    ) -> List[Dict[str, str]]:
+        context = rag_context
+        user_content = RAG_PROMPT.format(context=context, question=user_question) if context else user_question
+        messages = []
+        if self._system_prompt:
+            messages.append({"role": "system", "content": self._system_prompt})
+        messages.extend(self._get_history(session_id))
+        messages.append({"role": "user", "content": user_content})
+        return messages
+
+    def _build_tool_messages(self, session_id: str, user_question: str) -> List[Dict[str, str]]:
+        context, _ = self._rag.search(user_question)
+        messages = self._build_messages(session_id, user_question, context)
+        insert_at = 1 if messages and messages[0].get("role") == "system" else 0
+        messages.insert(insert_at, {"role": "system", "content": TOOL_ROUTING_PROMPT})
+        return messages
+
+    def tool_call_stream(self, session_id: str, question: str, tools) -> Generator[dict, None, None]:
+        """
+        带工具调用的流式对话（支持交错思考与工具调用）
+        - stream=True + tool_stream=True：模型在流式输出中同时返回推理过程、回答内容与工具调用
+        - 工具执行结果回传模型后继续流式生成，循环直至模型不再调用工具或达到最大轮次
+        """
+        if not self._check_question_valid(question):
+            yield {"session_id": session_id, "delta": self._rejection_message, "finish_reason": "rejected"}
+            return
+
+        def event(delta: str, etype: str) -> dict:
+            return {"session_id": session_id, "delta": delta, "type": etype, "finish_reason": None}
+
+        try:
+            messages = self._build_tool_messages(session_id, question)
+            max_rounds = config.tools.get("max_rounds", 5)
+            final_answer = ""
+
+            for _ in range(max_rounds):
+                response = self._client.chat.completions.create(
+                    model=self._model,
+                    messages=messages,
+                    tools=tools,
+                    tool_choice="auto",
+                    stream=True,
+                    tool_stream=True,
+                    max_tokens=self._max_tokens,
+                    temperature=self._temperature,
+                    top_p=self._top_p,
+                )
+
+                current_content = ""
+                tool_calls_map: Dict[int, Dict] = {}
+
+                for chunk in response:
+                    if not chunk.choices:
+                        continue
+                    delta = chunk.choices[0].delta
+
+                    reasoning = getattr(delta, "reasoning_content", None)
+                    if reasoning:
+                        yield event(reasoning, "reasoning")
+
+                    content = getattr(delta, "content", None)
+                    if content:
+                        current_content += content
+                        yield event(content, "content")
+
+                    for tc in getattr(delta, "tool_calls", None) or []:
+                        self._merge_tool_call_delta(tool_calls_map, tc)
+
+                if not tool_calls_map:
+                    final_answer = current_content
+                    break
+
+                assistant_tool_calls = [tool_calls_map[i] for i in sorted(tool_calls_map)]
+                messages.append({
+                    "role": "assistant",
+                    "content": current_content or None,
+                    "tool_calls": assistant_tool_calls,
+                })
+
+                for tc in assistant_tool_calls:
+                    name = tc["function"]["name"]
+                    args = tc["function"]["arguments"]
+                    yield event(f"\n[调用工具: {name}({args})]\n", "tool_call")
+
+                    result = call_function(name, args)
+                    yield event(result, "tool_result")
+
+                    messages.append({
+                        "role": "tool",
+                        "content": result,
+                        "tool_call_id": tc["id"],
+                    })
+            else:
+                final_answer = current_content or "[系统提示: 工具调用轮次已达上限]"
+                yield event(final_answer, "content")
+
+            self._append_exchange(session_id, question, final_answer)
+            yield {"session_id": session_id, "delta": "", "finish_reason": "stop"}
+
+        except Exception as e:
+            yield {
+                "session_id": session_id,
+                "delta": f"[错误] 模型调用异常: {str(e)}",
+                "finish_reason": "error",
+            }
+
+    @staticmethod
+    def _merge_tool_call_delta(tool_calls_map: Dict[int, Dict], tc) -> None:
+        """将单个流式 tool_call 增量按 index 合并到累积字典中"""
+        slot = tool_calls_map.setdefault(tc.index, {
+            "id": "",
+            "type": "function",
+            "function": {"name": "", "arguments": ""},
+        })
+        if tc.id:
+            slot["id"] = tc.id
+        fn = getattr(tc, "function", None)
+        if fn is not None:
+            if getattr(fn, "name", None):
+                slot["function"]["name"] += fn.name
+            if getattr(fn, "arguments", None):
+                slot["function"]["arguments"] += fn.arguments
+
+
+chat_service = ChatService()

package/src/service/rag_service.py

@@ -0,0 +1,154 @@
+import hashlib
+import re
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+import yaml
+from zai import ZhipuAiClient
+
+from src.core.config_loader import config
+
+
+class RagService:
+    """轻量 RAG 服务：加载 Markdown 知识库，写入 Chroma，并按问题检索。"""
+
+    def __init__(self):
+        self._cfg = config.get("rag", default={})
+        self._enabled = self._cfg.get("enabled", False)
+        self._top_k = self._cfg.get("top_k", 5)
+        self._collection = None
+        self._client = ZhipuAiClient(
+            api_key=config.llm.get("api_key"),
+            base_url=config.llm.get("base_url"),
+        )
+        if self._enabled:
+            self._init_collection()
+
+    def search(self, question: str) -> Tuple[str, List[Dict]]:
+        if not self._collection:
+            return "", []
+
+        try:
+            if self._collection.count() == 0:
+                self.rebuild()
+            if self._collection.count() == 0:
+                return "", []
+            result = self._collection.query(
+                query_embeddings=[self._embed(question)],
+                n_results=self._top_k,
+                include=["documents", "metadatas"],
+            )
+        except Exception:
+            self._collection = None
+            return "", []
+        docs = result.get("documents", [[]])[0]
+        metas = result.get("metadatas", [[]])[0]
+        sources = [self._source(m) for m in metas]
+        context = "\n\n".join(
+            f"[{i + 1}] 标题：{m.get('title', '')}\n"
+            f"来源：{m.get('source_doc', '')} {m.get('source_section', '')}\n"
+            f"内容：{doc}"
+            for i, (doc, m) in enumerate(zip(docs, metas))
+        )
+        return context, sources
+
+    def _init_collection(self):
+        try:
+            import chromadb
+        except ImportError:
+            return
+
+        root = Path(__file__).resolve().parents[2]
+        persist_dir = root / self._cfg.get("persist_dir", ".chroma")
+        self._knowledge_dir = root / self._cfg.get("knowledge_dir", "knowledge")
+        chroma = chromadb.PersistentClient(path=str(persist_dir))
+        self._collection = chroma.get_or_create_collection(self._cfg.get("collection", "ops_knowledge"))
+        try:
+            if self._cfg.get("rebuild_on_startup", False):
+                self.rebuild()
+        except Exception:
+            self._collection = None
+
+    def rebuild(self):
+        docs = self._load_documents()
+        if not docs:
+            return
+        self._collection.upsert(
+            ids=[d["id"] for d in docs],
+            documents=[d["content"] for d in docs],
+            metadatas=[d["metadata"] for d in docs],
+            embeddings=[self._embed(d["content"]) for d in docs],
+        )
+
+    def _load_documents(self) -> List[Dict]:
+        docs = []
+        for path in self._knowledge_dir.rglob("*.md"):
+            metadata, body = self._read_markdown(path)
+            if metadata.get("status", "active") != "active":
+                continue
+            for idx, chunk in enumerate(self._split(body)):
+                item_meta = self._clean_metadata({**metadata, "file_path": str(path), "chunk_index": idx})
+                docs.append({
+                    "id": self._chunk_id(path, idx, chunk),
+                    "content": chunk,
+                    "metadata": item_meta,
+                })
+        return docs
+
+    @staticmethod
+    def _read_markdown(path: Path) -> Tuple[Dict, str]:
+        text = path.read_text(encoding="utf-8")
+        match = re.match(r"^---\n(.*?)\n---\n(.*)$", text, re.S)
+        if not match:
+            return {"title": path.stem, "status": "active"}, text
+        return yaml.safe_load(match.group(1)) or {}, match.group(2).strip()
+
+    def _split(self, text: str) -> List[str]:
+        max_chars = self._cfg.get("chunk_size", 1200)
+        parts = re.split(r"\n(?=##\s+)", text)
+        chunks = []
+        for part in parts:
+            part = part.strip()
+            if not part:
+                continue
+            if len(part) <= max_chars:
+                chunks.append(part)
+            else:
+                chunks.extend(part[i:i + max_chars] for i in range(0, len(part), max_chars))
+        return chunks
+
+    def _embed(self, text: str) -> List[float]:
+        response = self._client.embeddings.create(
+            model=self._cfg.get("embedding_model", "embedding-3"),
+            input=text[: self._cfg.get("embedding_max_chars", 6000)],
+        )
+        item = response.data[0]
+        return item["embedding"] if isinstance(item, dict) else item.embedding
+
+    @staticmethod
+    def _clean_metadata(metadata: Dict) -> Dict:
+        cleaned = {}
+        for key, value in metadata.items():
+            if isinstance(value, list):
+                cleaned[key] = ",".join(map(str, value))
+            elif value is None:
+                cleaned[key] = ""
+            elif isinstance(value, (str, int, float, bool)):
+                cleaned[key] = value
+            else:
+                cleaned[key] = str(value)
+        return cleaned
+
+    @staticmethod
+    def _chunk_id(path: Path, idx: int, chunk: str) -> str:
+        digest = hashlib.md5(f"{path}:{idx}:{chunk}".encode("utf-8")).hexdigest()
+        return digest
+
+    @staticmethod
+    def _source(metadata: Dict) -> Dict:
+        return {
+            "title": metadata.get("title", ""),
+            "source_doc": metadata.get("source_doc", ""),
+            "source_section": metadata.get("source_section", ""),
+            "file_path": metadata.get("file_path", ""),
+        }