从零到上线：RAG 知识库助手保姆级教程

1
传感器 CSV ──► ①清洗 ──► ②双规则异常检测 ──► ③汇总 24h 指标
2
                                              │
3
                    设备手册.txt ──► ④关键词检索处置建议
4
                                              │
5
                                              ▼
6
                              ⑤大模型生成自然语言日报（qwen-turbo）

1
"""
2
Qwen3 演示项目 - 后端（含 RAG 知识库）
3
两种模式（环境变量切换）：云端 API / 本地 Ollama 私有化
4
"""
5
import io
6
import json
7
import os
8

9
import httpx
10
from fastapi import Depends, FastAPI, Header, HTTPException, UploadFile
11
from fastapi.middleware.cors import CORSMiddleware
12
from fastapi.responses import StreamingResponse
13
from pydantic import BaseModel, Field
14

15
from rag_store import VectorStore, chunk_text
16

17
# ---------------- 配置 ----------------
18
LLM_BASE_URL = os.getenv("LLM_BASE_URL", "https://dashscope.aliyuncs.com/compatible-mode/v1")
19
LLM_API_KEY = os.getenv("LLM_API_KEY", os.getenv("DASHSCOPE_API_KEY", ""))
20
CHAT_MODEL = os.getenv("QWEN_MODEL", "qwen-turbo")
21
EMBED_MODEL = os.getenv("EMBED_MODEL", "text-embedding-v3")
22
CHAT_URL = f"{LLM_BASE_URL}/chat/completions"
23
EMBED_URL = f"{LLM_BASE_URL}/embeddings"
24
ALLOWED_EXT = {".txt", ".md", ".pdf"}
25
# 公网部署必配：设置后所有 /api/* 请求需携带 X-Access-Token 头
26
ACCESS_TOKEN = os.getenv("ACCESS_TOKEN", "")
27

28
def require_token(x_token: str | None = Header(default=None, alias="X-Access-Token")):
29
    if ACCESS_TOKEN and x_token != ACCESS_TOKEN:
30
        raise HTTPException(401, "缺少或错误的访问令牌（联系管理员获取）")
31

32
app = FastAPI(title="Qwen3 RAG Demo API")
33
app.add_middleware(
34
    CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"]
35
)
36

37
kb = VectorStore()
38
kb.load()
39

40
# ---------------- 基础工具 ----------------
41
async def embed_texts(texts: list[str]) -> list[list[float]]:
42
    """批量向量化（百炼单次最多 10 条，分批调用）。"""
43
    out: list[list[float]] = []
44
    async with httpx.AsyncClient(timeout=60) as client:
45
        for i in range(0, len(texts), 10):
46
            r = await client.post(
47
                EMBED_URL,
48
                headers={"Authorization": f"Bearer {LLM_API_KEY}"},
49
                json={"model": EMBED_MODEL, "input": texts[i : i + 10]},
50
            )
51
            if r.status_code != 200:
52
                raise HTTPException(502, f"向量化失败: {r.text[:300]}")
53
            items = r.json()["data"]
54
            out += [item["embedding"] for item in sorted(items, key=lambda x: x["index"])]
55
    return out
56

57
def extract_pdf(data: bytes) -> str:
58
    try:
59
        from pypdf import PdfReader
60
    except ImportError:
61
        raise HTTPException(500, "服务器未安装 pypdf（pip install pypdf）")
62
    reader = PdfReader(io.BytesIO(data))
63
    return "\n".join(page.extract_text() or "" for page in reader.pages)
64

65
def extract_text(filename: str, data: bytes) -> str:
66
    ext = os.path.splitext(filename)[1].lower()
67
    if ext not in ALLOWED_EXT:
68
        raise HTTPException(400, f"仅支持 {'/'.join(ALLOWED_EXT)} 格式")
69
    if ext == ".pdf":
70
        return extract_pdf(data)
71
    return data.decode("utf-8", errors="ignore")
72

73
# ---------------- 接口 ----------------
74
class ChatMessage(BaseModel):
75
    role: str = Field(pattern="^(system|user|assistant)$")
76
    content: str
77

78
class ChatRequest(BaseModel):
79
    messages: list[ChatMessage]
80
    max_tokens: int = 1024
81

82
@app.get("/api/health")
83
def health():
84
    return {"status": "ok", "model": CHAT_MODEL, "kb_chunks": kb.count}
85

86
@app.post("/api/upload")
87
async def upload(file: UploadFile, _=Depends(require_token)):
88
    if not LLM_API_KEY:
89
        raise HTTPException(500, "服务端未配置 LLM_API_KEY")
90
    data = await file.read()
91
    if len(data) > 10 * 1024 * 1024:
92
        raise HTTPException(400, "文件超过 10MB 限制")
93
    text = extract_text(file.filename, data)
94
    if len(text.strip()) < 10:
95
        raise HTTPException(400, "未能提取到有效文本内容")
96
    chunks = chunk_text(text)
97
    vectors = await embed_texts(chunks)
98
    n = kb.add(file.filename, chunks, vectors)
99
    return {"doc": file.filename, "chunks": n, "kb_total_chunks": kb.count}
100

101
@app.get("/api/kb")
102
def kb_status():
103
    docs = {}
104
    for m in kb.meta:
105
        d = docs.setdefault(m["doc_id"], {"name": m["name"], "chunks": 0})
106
        d["chunks"] += 1
107
    return {"total_chunks": kb.count, "docs": list(docs.values())}
108

109
@app.delete("/api/kb")
110
def kb_clear():
111
    kb.clear()
112
    return {"status": "cleared"}
113

114
@app.get("/api/debug")
115
async def debug_search(q: str, token: str = ""):
116
    """调试接口：透视某问题的检索命中片段（排查 RAG 问题的关键工具）"""
117
    if ACCESS_TOKEN and token != ACCESS_TOKEN:
118
        raise HTTPException(401, "令牌错误")
119
    if kb.count == 0:
120
        return {"q": q, "kb_chunks": 0, "hits": []}
121
    q_vec = (await embed_texts([q]))[0]
122
    hits = kb.search(q_vec, top_k=6)
123
    return {
124
        "q": q, "kb_chunks": kb.count,
125
        "hits": [{"score": h["score"], "text": h["text"][:150]} for h in hits],
126
    }
127

128
@app.post("/api/chat")
129
async def chat(req: ChatRequest, _=Depends(require_token)):
130
    if not LLM_API_KEY:
131
        raise HTTPException(500, "服务端未配置 LLM_API_KEY")
132
    last_user = next((m.content for m in reversed(req.messages) if m.role == "user"), "")
133
    if not last_user:
134
        raise HTTPException(400, "缺少用户消息")
135

136
    # ---- RAG 检索 ----
137
    sources, context_block = [], ""
138
    if kb.count > 0:
139
        q_vec = (await embed_texts([last_user]))[0]
140
        hits = kb.search(q_vec, top_k=6)
141
        if hits:
142
            refs = "\n\n".join(
143
                f"[{i + 1}] （来源：{h['name']}）\n{h['text']}"
144
                for i, h in enumerate(hits)
145
            )
146
            context_block = (
147
                f"以下是知识库中检索到的参考资料：\n\n{refs}\n\n"
148
                "回答要求（必须严格遵守）：\n"
149
                "1. 只能依据参考资料回答具体问题；若参考资料中找不到答案，"
150
                "必须第一句就说明「知识库中没有相关内容」，不得编造数字或事实；\n"
151
                "2. 依据资料回答时，在对应内容后标注引用序号，如 [1]；\n"
152
                "3. 参考资料与问题无关时，忽略资料，不要引用。"
153
            )
154
            sources = [
155
                {"idx": i + 1, "name": h["name"], "score": h["score"],
156
                 "snippet": h["text"][:120] + ("…" if len(h["text"]) > 120 else "")}
157
                for i, h in enumerate(hits)
158
            ]
159

160
    system_prompt = (
161
        "你是企业智能助手「小千」，回答简洁、专业、友好。"
162
        + (("\n\n" + context_block) if context_block else "")
163
    )
164

165
    payload = {
166
        "model": CHAT_MODEL,
167
        "messages": [
168
            {"role": "system", "content": system_prompt},
169
            *[m.model_dump() for m in req.messages],
170
        ],
171
        "max_tokens": req.max_tokens,
172
        "stream": True,
173
        "enable_thinking": False,
174
    }
175
    headers = {"Authorization": f"Bearer {LLM_API_KEY}"}
176

177
    async def event_stream():
178
        async with httpx.AsyncClient(timeout=120) as client:
179
            async with client.stream("POST", CHAT_URL, json=payload, headers=headers) as r:
180
                if r.status_code != 200:
181
                    body = (await r.aread()).decode("utf-8", "ignore")
182
                    yield f"data: {json.dumps({'error': body})}\n\n"
183
                    return
184
                async for line in r.aiter_lines():
185
                    if line.startswith("data:"):
186
                        chunk = line[5:].strip()
187
                        if chunk == "[DONE]":
188
                            break
189
                        try:
190
                            delta = json.loads(chunk)["choices"][0]["delta"].get("content", "")
191
                        except Exception:
192
                            continue
193
                        if delta:
194
                            yield f"data: {json.dumps({'content': delta}, ensure_ascii=False)}\n\n"
195
        if sources:
196
            yield f"data: {json.dumps({'sources': sources}, ensure_ascii=False)}\n\n"
197
        yield "data: [DONE]\n\n"
198

199
    return StreamingResponse(
200
        event_stream(),
201
        media_type="text/event-stream",
202
        headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
203
    )

1
"""
2
轻量级本地向量知识库
3
- 不依赖外部数据库：向量存 numpy 文件、元数据存 JSON
4
- 中文友好切分（语义边界 + 重叠）；余弦相似度检索
5
- 生产环境可平滑替换为 Qdrant/Milvus，接口不变
6
"""
7
import json
8
import os
9
import re
10

11
import numpy as np
12

13
STORE_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "data")
14
INDEX_PATH = os.path.join(STORE_DIR, "kb_index.npz")
15
META_PATH = os.path.join(STORE_DIR, "kb_meta.json")
16

17
def chunk_text(text: str, size: int = 280, overlap: int = 60) -> list[str]:
18
    """按长度切分，并在标点/换行边界尽量断开，保留 overlap 重叠。"""
19
    text = re.sub(r"\r\n?", "\n", text)
20
    text = re.sub(r"\n{3,}", "\n\n", text).strip()
21
    if len(text) <= size:
22
        return [text] if text else []
23

24
    chunks, start = [], 0
25
    while start < len(text):
26
        end = min(start + size, len(text))
27
        if end < len(text):
28
            # 在窗口后 1/3 内寻找语义边界
29
            window = text[start + size // 2 : end]
30
            for sep in ["\n\n", "。", "！", "？", "；", "\n", "，"]:
31
                pos = window.rfind(sep)
32
                if pos != -1:
33
                    end = start + size // 2 + pos + len(sep)
34
                    break
35
        chunk = text[start:end].strip()
36
        if chunk:
37
            chunks.append(chunk)
38
        if end >= len(text):
39
            break  # 已覆盖到结尾，防止 start 以 1 字符步进死循环产生大量碎块
40
        start = max(end - overlap, start + 1)  # 防死循环
41
    return chunks
42

43
class VectorStore:
44
    def __init__(self):
45
        os.makedirs(STORE_DIR, exist_ok=True)
46
        self.vectors = None      # ndarray (n, dim)
47
        self.meta = []           # [{"doc_id","name","chunk_id","text"}]
48

49
    def load(self) -> bool:
50
        if os.path.exists(INDEX_PATH) and os.path.exists(META_PATH):
51
            data = np.load(INDEX_PATH)
52
            self.vectors = data["vectors"]
53
            with open(META_PATH, encoding="utf-8") as f:
54
                self.meta = json.load(f)
55
            return True
56
        return False
57

58
    def save(self):
59
        if self.vectors is not None:
60
            np.savez_compressed(INDEX_PATH, vectors=self.vectors)
61
        with open(META_PATH, "w", encoding="utf-8") as f:
62
            json.dump(self.meta, f, ensure_ascii=False)
63

64
    @property
65
    def count(self) -> int:
66
        return 0 if self.vectors is None else len(self.vectors)
67

68
    def add(self, doc_name: str, chunks: list[str], vectors: list[list[float]]) -> int:
69
        new_vec = np.array(vectors, dtype=np.float32)
70
        self.vectors = new_vec if self.vectors is None else np.vstack([self.vectors, new_vec])
71
        base = max((m["doc_id"] for m in self.meta), default=0) + 1
72
        for i, c in enumerate(chunks):
73
            self.meta.append({"doc_id": base, "name": doc_name, "chunk_id": i, "text": c})
74
        self.save()
75
        return len(chunks)
76

77
    def search(self, query_vec: list[float], top_k: int = 4) -> list[dict]:
78
        if self.count == 0:
79
            return []
80
        q = np.array(query_vec, dtype=np.float32)
81
        scores = self.vectors @ q / (
82
            np.linalg.norm(self.vectors, axis=1) * np.linalg.norm(q) + 1e-9
83
        )
84
        top = np.argsort(scores)[::-1][:top_k]
85
        hits = []
86
        for i in top:
87
            if scores[i] < 0.45:  # 相似度过低的丢弃（防弱相关上下文诱发幻觉）
88
                continue
89
            m = dict(self.meta[i])
90
            m["score"] = round(float(scores[i]), 4)
91
            hits.append(m)
92
        return hits
93

94
    def clear(self):
95
        self.vectors = None
96
        self.meta = []
97
        for p in (INDEX_PATH, META_PATH):
98
            if os.path.exists(p):
99
                os.remove(p)

1
#!/bin/bash
2
# 用法：代码放 /opt/qwen3-demo 后，root 执行：
3
#   LLM_API_KEY=sk-xxx ACCESS_TOKEN=你的令牌 bash deploy.sh
4
set -e
5
if [ -z "$LLM_API_KEY" ] || [ -z "$ACCESS_TOKEN" ]; then
6
  echo "用法: LLM_API_KEY=sk-xxx ACCESS_TOKEN=你的令牌 bash deploy.sh"; exit 1
7
fi
8
[ "$(id -u)" != "0" ] && { echo "请用 root 执行"; exit 1; }
9
[ ! -d /opt/qwen3-demo/backend ] && { echo "请先把代码上传到 /opt/qwen3-demo"; exit 1; }
10

11
echo "==> 1/5 安装基础软件"
12
apt update -y && apt install -y python3-pip nginx curl
13

14
echo "==> 2/5 配置 2G swap"
15
if [ ! -f /swapfile ]; then
16
  fallocate -l 2G /swapfile && chmod 600 /swapfile
17
  mkswap /swapfile && swapon /swapfile
18
  grep -q swapfile /etc/fstab || echo '/swapfile none swap sw 0 0' >> /etc/fstab
19
fi
20

21
echo "==> 3/5 安装后端依赖"
22
cd /opt/qwen3-demo/backend
23
pip3 install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
24

25
echo "==> 4/5 配置 systemd 常驻服务"
26
cat > /etc/systemd/system/qwen-api.service <<EOF
27
[Unit]
28
Description=Qwen3 RAG Demo API
29
After=network.target
30
[Service]
31
User=root
32
WorkingDirectory=/opt/qwen3-demo/backend
33
Environment=LLM_API_KEY=${LLM_API_KEY}
34
Environment=QWEN_MODEL=${QWEN_MODEL:-qwen-turbo}
35
Environment=ACCESS_TOKEN=${ACCESS_TOKEN}
36
ExecStart=/usr/local/bin/uvicorn main:app --host 127.0.0.1 --port 8000
37
Restart=always
38
RestartSec=5
39
[Install]
40
WantedBy=multi-user.target
41
EOF
42
systemctl daemon-reload && systemctl enable --now qwen-api
43

44
echo "==> 5/5 配置 Nginx（前端 + 反向代理）"
45
cat > /etc/nginx/sites-available/default <<'EOF'
46
server {
47
    listen 80 default_server;
48
    root /var/www/html;
49
    index index.html;
50
    location /api/ {
51
        proxy_pass http://127.0.0.1:8000;
52
        proxy_http_version 1.1;
53
        proxy_set_header Connection "";
54
        proxy_buffering off;          # SSE 流式必须关缓冲
55
        proxy_read_timeout 300s;
56
    }
57
}
58
EOF
59
cp /opt/qwen3-demo/frontend/index.html /var/www/html/index.html
60
nginx -t && systemctl reload nginx
61
sleep 2
62
curl -s http://127.0.0.1:8000/api/health && echo ""
63
IP=$(curl -s --connect-timeout 3 ifconfig.me || echo 服务器IP)
64
echo "部署完成！浏览器访问:  http://${IP}/?token=${ACCESS_TOKEN}"

1
// ① 后端地址与令牌：默认同源（Nginx 反代），可用 URL 参数覆盖
2
const params = new URLSearchParams(location.search);
3
const API = params.get("api") || (location.protocol === "file:" ? "http://localhost:8000" : location.origin);
4
const TOKEN = params.get("token") || "";
5
const authHeaders = TOKEN ? { "X-Access-Token": TOKEN } : {};
6

7
// ② SSE 流式读取（打字机效果核心）
8
const reader = resp.body.getReader();
9
const decoder = new TextDecoder();
10
let buf = "", full = "";
11
while (true) {
12
  const { done, value } = await reader.read();
13
  if (done) break;
14
  buf += decoder.decode(value, { stream: true });
15
  let idx;
16
  while ((idx = buf.indexOf("\n\n")) >= 0) {
17
    const line = buf.slice(0, idx).trim(); buf = buf.slice(idx + 2);
18
    if (!line.startsWith("data:")) continue;
19
    const data = line.slice(5).trim();
20
    if (data === "[DONE]") continue;
21
    const j = JSON.parse(data);
22
    if (j.error) throw new Error(j.error);
23
    if (j.sources) { addSources(j.sources); continue; }   // 引用来源标签
24
    full += j.content || "";
25
    bot.textContent = full;                                // 逐字渲染
26
    chatEl.scrollTop = chatEl.scrollHeight;
27
  }
28
}
29

30
// ③ 多轮对话记忆：滑动窗口只保留最近 10 轮，控制上下文成本
31
body: JSON.stringify({ messages: history.slice(-10) })
32

33
// ④ 设备健康日报按钮（v7：令牌同时放 URL 参数和请求头，两种鉴权接口都兼容）
34
document.getElementById("reportBtn").onclick = async () => {
35
  const el = addMsg("bot", "📊 正在分析设备数据并生成日报…");
36
  const r = await fetch(API + "/api/report?token=" + encodeURIComponent(TOKEN), { headers: authHeaders });
37
  const j = await r.json();
38
  el.textContent = "📊 设备健康日报（最近 24 小时）\n\n" + (j.report || JSON.stringify(j));
39
};

1
"""
2
设备健康日报模块（融合进 qwen3-demo）
3
链路：传感器 CSV → 清洗 → 双规则异常检测 → 汇总 24h 指标
4
     → 检索设备手册处置建议 → 大模型生成自然语言日报
5
"""
6
import json
7
import os
8

9
import numpy as np
10
import pandas as pd
11

12
# 数据文件默认放在 qwen3-demo/backend/data/ 下，可用环境变量覆盖
13
DATA_CSV = os.getenv("EQUIPMENT_CSV",
14
                     os.path.join(os.path.dirname(os.path.abspath(__file__)), "data", "equipment_data.csv"))
15
MANUAL = os.getenv("EQUIPMENT_MANUAL",
16
                   os.path.join(os.path.dirname(os.path.abspath(__file__)), "data", "设备手册.txt"))
17

18
WINDOW, SIGMA = 48, 3.0
19
THRESH = {"vib_high": 4.5, "temp_high": 75.0}
20

21
LLM_BASE_URL = os.getenv("LLM_BASE_URL", "https://dashscope.aliyuncs.com/compatible-mode/v1")
22
LLM_API_KEY = os.getenv("LLM_API_KEY", "")
23
MODEL = os.getenv("QWEN_MODEL", "qwen-turbo")
24

25

26
def _clean(df: pd.DataFrame) -> pd.DataFrame:
27
    df = df.drop_duplicates()
28
    for col in ["temperature", "vibration", "current"]:
29
        df.loc[df[col] == 0, col] = np.nan          # 0 值是断线，不是真 0
30
    df = df.sort_values(["machine_id", "timestamp"])
31
    for col in ["temperature", "vibration", "current"]:
32
        df[col] = df.groupby("machine_id")[col].transform(   # transform 不丢分组列
33
            lambda s: s.interpolate(limit_direction="both").fillna(s.median())
34
        )
35
    return df
36

37

38
def _detect(df: pd.DataFrame) -> pd.DataFrame:
39
    def rolling_sigma(g: pd.DataFrame) -> pd.DataFrame:
40
        for col in ["temperature", "vibration"]:
41
            m = g[col].rolling(WINDOW, min_periods=24).mean()
42
            s = g[col].rolling(WINDOW, min_periods=24).std()
43
            g[f"{col}_z"] = ((g[col] - m) / s.replace(0, np.nan)).round(2)
44
        g["sigma_alert"] = (g["temperature_z"].abs() > SIGMA) | (g["vibration_z"].abs() > SIGMA)
45
        return g
46

47
    df = pd.concat([rolling_sigma(g) for _, g in df.groupby("machine_id")]).sort_index()
48
    df["rule_alert"] = (df["temperature"] > THRESH["temp_high"]) | (df["vibration"] > THRESH["vib_high"])
49
    df["alert"] = df["rule_alert"] | df["sigma_alert"]
50
    return df
51

52

53
def build_summary() -> dict:
54
    """读取设备数据，完成清洗与检测，汇总最近 24 小时指标。"""
55
    if not os.path.exists(DATA_CSV):
56
        return {"error": f"未找到设备数据文件：{DATA_CSV}"}
57
    df = _detect(_clean(pd.read_csv(DATA_CSV, parse_dates=["timestamp"])))
58
    latest = df[df["timestamp"] >= df["timestamp"].max() - pd.Timedelta(hours=23)]
59
    rows = []
60
    for mid, g in latest.groupby("machine_id"):
61
        prev = df[(df["machine_id"] == mid) &
62
                  (df["timestamp"] < df["timestamp"].max() - pd.Timedelta(hours=24))]
63
        vib_now, vib_prev = g["vibration"].mean(), prev["vibration"].mean()
64
        item = {
65
            "设备": mid,
66
            "平均温度": round(float(g["temperature"].mean()), 1),
67
            "最高振动": round(float(g["vibration"].max()), 2),
68
            "振动环比": f"{(vib_now - vib_prev) / vib_prev * 100:+.1f}%",
69
            "产量": int(g["output_count"].sum()),
70
            "异常次数": int(g["alert"].sum()),
71
        }
72
        if item["异常次数"] >= 8 or item["最高振动"] > THRESH["vib_high"] + 0.8:
73
            item["风险"] = "高风险"
74
        elif item["异常次数"] >= 3 or item["最高振动"] > THRESH["vib_high"] - 0.5:
75
            item["风险"] = "关注"
76
        else:
77
            item["风险"] = "正常"
78
        rows.append(item)
79
    return {"周期": "最近 24 小时", "设备": rows}
80

81

82
def lookup_manual(keyword: str) -> str:
83
    """从设备手册中按关键词取处置建议（轻量检索，生产可换 RAG 向量检索）。"""
84
    if not os.path.exists(MANUAL):
85
        return ""
86
    text = open(MANUAL, encoding="utf-8").read()
87
    for block in text.split("\n\n"):
88
        if keyword in block:
89
            return block.strip()[:300]
90
    return ""
91

92

93
async def generate_report_text(summary: dict) -> str:
94
    """调用大模型把结构化指标翻译成自然语言日报。"""
95
    import httpx
96
    body = json.dumps(summary, ensure_ascii=False, indent=2)
97
    hints = []
98
    for m in summary.get("设备", []):
99
        if m["风险"] != "正常":
100
            tip = lookup_manual("主轴过热") if m["平均温度"] > 60 else lookup_manual("振动")
101
            if tip:
102
                hints.append(f"【{m['设备']}】参考手册建议：{tip}")
103
    prompt = (
104
        "你是工厂设备管理员助手。根据以下设备监控数据，写一份给车间主任看的《设备健康日报》。\n"
105
        "要求：① 先一句话说总体情况；② 高风险设备单独列出问题和建议动作；"
106
        "③ 语言简洁、面向一线，不要堆砌术语；④ 不超过 300 字。\n\n"
107
        f"监控数据：\n{body}\n"
108
        + ("\n参考建议：\n" + "\n".join(hints) if hints else "")
109
    )
110
    if not LLM_API_KEY:
111
        return "（未配置 LLM_API_KEY，以下为结构化数据）\n\n" + body
112
    try:
113
        async with httpx.AsyncClient(timeout=120) as client:
114
            r = await client.post(
115
                f"{LLM_BASE_URL}/chat/completions",
116
                headers={"Authorization": f"Bearer {LLM_API_KEY}"},
117
                json={"model": MODEL, "messages": [{"role": "user", "content": prompt}],
118
                      "enable_thinking": False},
119
            )
120
            r.raise_for_status()
121
            return r.json()["choices"][0]["message"]["content"]
122
    except Exception as e:
123
        return f"（模型调用失败：{e}）以下是结构化数据：\n\n{body}"