doorcore 0.1.0__py3-none-any.whl

doorcore/__init__.py

@@ -0,0 +1,9 @@
+"""doorcore — door-Core v2 本地 AI 引擎（可 pip 安装的公开库）"""
+
+__version__ = "0.1.0"
+
+from .core import DoorCore
+from .api import application, get_ai
+from .cli import main as cli_main
+
+__all__ = ["DoorCore", "application", "get_ai", "cli_main", "__version__"]

doorcore/api.py

@@ -0,0 +1,127 @@
+# door-core v2 —— 零依赖 OpenAI 兼容 API + 可部署 WSGI application
+# 本地运行：  python api.py            -> http://localhost:8765/v1
+# 公网部署：  平台 import 本文件的 application（WSGI）即可，模型名 door-core
+import os
+import json
+import importlib.resources as _resources
+
+from http.server import ThreadingHTTPServer, BaseHTTPRequestHandler
+from doorcore.core import DoorCore
+
+
+def _pkg_path(*parts):
+    try:
+        return str(_resources.files("doorcore").joinpath(*parts))
+    except Exception:
+        return os.path.join(os.path.dirname(os.path.abspath(__file__)), *parts)
+
+
+def load_config():
+    p = _pkg_path("data", "config.json")
+    if os.path.exists(p):
+        try:
+            return json.load(open(p, encoding="utf-8"))
+        except Exception:
+            pass
+    return {"n": 3}
+
+
+cfg = load_config()
+_AI = None
+
+
+def get_ai():
+    global _AI
+    if _AI is None:
+        n = int(cfg.get("n", 3))
+        _AI = DoorCore(n=n)
+        _AI.load_or_train()
+    return _AI
+
+
+def _chat_reply(messages):
+    text = ""
+    for m in reversed(messages or []):
+        if m.get("role") == "user":
+            text = m.get("content", "")
+            break
+    return get_ai().ask(text)
+
+
+def _completion_obj(reply):
+    return {
+        "object": "chat.completion",
+        "model": "door-core",
+        "choices": [{
+            "index": 0,
+            "message": {"role": "assistant", "content": reply},
+            "finish_reason": "stop",
+        }],
+        "usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0},
+    }
+
+
+def _body_str(obj):
+    return json.dumps(obj, ensure_ascii=False).encode("utf-8")
+
+
+class Handler(BaseHTTPRequestHandler):
+    def _send(self, code, obj):
+        body = _body_str(obj)
+        self.send_response(code)
+        self.send_header("Content-Type", "application/json; charset=utf-8")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_POST(self):
+        if self.path.rstrip("/") not in ("/v1/chat/completions", "/chat/completions"):
+            self._send(404, {"error": "not found"})
+            return
+        try:
+            ln = int(self.headers.get("Content-Length", 0) or 0)
+            raw = self.rfile.read(ln) if ln else b""
+            data = json.loads(raw.decode("utf-8"))
+        except Exception as e:
+            self._send(400, {"error": str(e)})
+            return
+        self._send(200, _completion_obj(_chat_reply(data.get("messages", []))))
+
+    def log_message(self, *a):
+        pass
+
+
+def application(environ, start_response):
+    path = (environ.get("PATH_INFO", "") or "").rstrip("/")
+    if environ.get("REQUEST_METHOD") == "POST" and path in (
+            "/v1/chat/completions", "/chat/completions"):
+        try:
+            ln = int(environ.get("CONTENT_LENGTH", 0) or 0)
+            raw = environ["wsgi.input"].read(ln) if ln else b""
+            data = json.loads(raw.decode("utf-8"))
+            reply = _chat_reply(data.get("messages", []))
+        except Exception as e:
+            reply = "出错了：" + str(e)
+        body = _body_str(_completion_obj(reply))
+        start_response("200 OK", [
+            ("Content-Type", "application/json; charset=utf-8"),
+            ("Content-Length", str(len(body))),
+        ])
+        return [body]
+    body = b'{"error":"not found"}'
+    start_response("404 Not Found", [
+        ("Content-Type", "application/json"),
+        ("Content-Length", str(len(body))),
+    ])
+    return [body]
+
+
+def main():
+    port = int(os.environ.get("PORT", "8765"))
+    print(f"[door-core v2 API] http://localhost:{port}/v1  (模型名 door-core)")
+    httpd = ThreadingHTTPServer(("0.0.0.0", port), Handler)
+    httpd.serve_forever()
+
+
+if __name__ == "__main__":
+    main()

doorcore/cli.py

@@ -0,0 +1,57 @@
+# door-core v2 —— 命令行聊天（训练并从 .txt 语料加载，结果存 model.pkl）
+import os
+import sys
+import json
+import importlib.resources as _resources
+
+from doorcore.core import DoorCore
+
+
+def _pkg_path(*parts):
+    try:
+        return str(_resources.files("doorcore").joinpath(*parts))
+    except Exception:
+        return os.path.join(os.path.dirname(os.path.abspath(__file__)), *parts)
+
+
+def load_config():
+    p = _pkg_path("data", "config.json")
+    if os.path.exists(p):
+        try:
+            return json.load(open(p, encoding="utf-8"))
+        except Exception:
+            pass
+    return {"n": 3}
+
+
+def main():
+    cfg = load_config()
+    n = int(cfg.get("n", 3))
+    ai = DoorCore(n=n)
+
+    force = "--retrain" in sys.argv
+    status = ai.load_or_train(force=force)
+    print(f"[door-core v2] 模型: {status} | 知识条目: {len(ai.kb)} | "
+          f"马尔可夫节点: {len(ai.model)}")
+    print("聊天开始（/retrain 重新训练, /quit 退出）")
+
+    while True:
+        try:
+            u = input("你> ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            break
+        if not u:
+            continue
+        if u in ("/quit", "/exit"):
+            break
+        if u == "/retrain":
+            ai.load_corpus()
+            ai.save_model()
+            print(f"已重新训练：知识条目 {len(ai.kb)}，马尔可夫节点 {len(ai.model)}")
+            continue
+        print("AI> " + ai.ask(u))
+
+
+if __name__ == "__main__":
+    main()

doorcore/core.py

@@ -0,0 +1,454 @@
+# door-core v2 —— 马尔可夫本地 AI（语料库从 .txt 路径加载，不内置）
+#
+# 知识库格式（沿用旧版）：每行  "问题===答案"
+#   - 含 === 的行：作为问答对进入检索库，同时喂给马尔可夫训练
+#   - 不含 === 的纯文本行：直接作为语料训练马尔可夫（可放任意 txt）
+# 所有 .txt 都放在 config.json 里 "corpus" 指定的路径（文件或目录）下即可。
+
+import os
+import re
+import json
+import math
+import random
+import pickle
+import glob
+import datetime
+import importlib.resources as _resources
+
+_HERE = os.path.dirname(os.path.abspath(__file__))
+
+
+def _pkg_path(*parts):
+    """优先从安装包内定位资源，失败则回退到源码目录。"""
+    try:
+        return str(_resources.files("doorcore").joinpath(*parts))
+    except Exception:
+        return os.path.join(_HERE, *parts)
+
+
+# 寒暄/问候：代码内的少量对话逻辑（不是知识库语料），短问候直接友好回复
+_GREETING_KEYWORDS = ["你好", "您好", "嗨", "哈喽", "在吗", "在么",
+                      "在不在", "早上好", "下午好", "晚上好",
+                      "hello", "hi", "hey", "喂"]
+_GREETING_FILLER = r'[\s，。！？!?,.，~～、；;：:呀啊哦呢哈呦哟嘿嘛儿呗]'
+_GREETING_REPLIES = [
+    "你好呀！我是 door-Core，一个完全离线、跑在你本地的智能助手。有什么想聊的或想问的？",
+    "嗨～我是 door-Core，本地离线 AI，随时陪你聊。",
+    "在的，我是 door-Core，一个完全本地运行的智能助手，问我就行～",
+]
+
+
+# 科学计算白名单：eval 只在下面这些名字里解析，__builtins__ 已清空，安全
+import math as _math
+_SAFE_MATH = {
+    # 基础
+    "abs": abs, "round": round, "min": min, "max": max, "pow": pow, "sum": sum,
+    # 幂 / 根 / 指数 / 对数
+    "sqrt": _math.sqrt, "cbrt": lambda x: x ** (1 / 3), "exp": _math.exp,
+    "log": _math.log, "log10": _math.log10, "log2": _math.log2,
+    "ln": _math.log, "lg": _math.log10,
+    # 取整
+    "floor": _math.floor, "ceil": _math.ceil,
+    # 三角（弧度）
+    "sin": _math.sin, "cos": _math.cos, "tan": _math.tan,
+    "asin": _math.asin, "acos": _math.acos, "atan": _math.atan,
+    "sinh": _math.sinh, "cosh": _math.cosh, "tanh": _math.tanh,
+    # 三角（角度制，方便直接算 sin(30)）
+    "sind": lambda x: _math.sin(_math.radians(x)),
+    "cosd": lambda x: _math.cos(_math.radians(x)),
+    "tand": lambda x: _math.tan(_math.radians(x)),
+    "asind": lambda x: _math.degrees(_math.asin(x)),
+    "acosd": lambda x: _math.degrees(_math.acos(x)),
+    "atand": lambda x: _math.degrees(_math.atan(x)),
+    # 角度换算
+    "radians": _math.radians, "degrees": _math.degrees,
+    # 数论
+    "factorial": _math.factorial, "gcd": _math.gcd, "lcm": _math.lcm,
+    "hypot": _math.hypot, "atan2": _math.atan2,
+    "perm": _math.perm, "comb": _math.comb,
+    # 便捷
+    "平方": lambda x: x ** 2, "立方": lambda x: x ** 3, "倒数": lambda x: 1 / x,
+    # 常数
+    "pi": _math.pi, "e": _math.e, "tau": _math.tau,
+    "圆周率": _math.pi, "自然常数": _math.e,
+    # 中文别名（沿用旧版 + 扩充）
+    "绝对值": abs, "开方": _math.sqrt, "平方根": _math.sqrt, "根号": _math.sqrt,
+    "四舍五入": round, "取整": round, "向下取整": _math.floor, "向上取整": _math.ceil,
+    "阶乘": _math.factorial, "对数": _math.log, "常用对数": _math.log10,
+    "正弦": _math.sin, "余弦": _math.cos, "正切": _math.tan,
+    "反正弦": _math.asin, "反余弦": _math.acos, "反正切": _math.atan,
+    "双曲正弦": _math.sinh, "双曲余弦": _math.cosh, "双曲正切": _math.tanh,
+    "弧度": _math.radians, "角度": _math.degrees, "指数": _math.exp,
+    "最大": max, "最小": min, "求和": sum,
+    "排列": _math.perm, "组合": _math.comb,
+}
+
+
+# 角色扮演：触发词 -> 每句后缀（要加更多角色，照这个格式加即可）
+ROLES = {
+    "猫娘": {
+        "triggers": ["猫娘", "喵娘", "catgirl", "猫娘模式", "扮演猫娘", "变成猫娘"],
+        "suffix": "喵",
+    },
+}
+
+
+class DoorCore:
+    def __init__(self, corpus_path=None, n=3, model_path=None):
+        self.n = n
+        self.model = {}          # (char,)*n -> [next_char, ...]
+        self.starters = []       # 句首 n-gram
+        self.kb = []             # [(q, a), ...] 检索库
+        self.jokes = []
+        self.trained = False
+        # 默认从包内 data 目录定位资源；传入参数可覆盖
+        self.corpus_path = corpus_path or _pkg_path("data", "corpus")
+        self.model_path = model_path or _pkg_path("data", "model.pkl")
+        self.role = None          # 当前角色扮演（None=关闭）
+
+    # ---------------- 语料加载（从路径读 .txt） ----------------
+    def _iter_txt(self):
+        if os.path.isdir(self.corpus_path):
+            files = sorted(glob.glob(os.path.join(self.corpus_path, "*.txt")))
+        elif os.path.isfile(self.corpus_path):
+            files = [self.corpus_path]
+        else:
+            files = []
+        for p in files:
+            try:
+                with open(p, "r", encoding="utf-8") as f:
+                    yield p, f.read()
+            except Exception:
+                pass
+
+    def load_corpus(self):
+        self.model = {}
+        self.starters = []
+        self.kb = []
+        self.jokes = []
+        for path, text in self._iter_txt():
+            self._ingest(text)
+        if self.kb or self.model:
+            self.trained = True
+
+    def _ingest(self, text):
+        for line in text.splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            if "===" in line:
+                q, a = line.split("===", 1)
+                q, a = q.strip(), a.strip()
+                if q and a:
+                    self.kb.append((q, a))
+                    self._train_text(q + "。" + a)
+            else:
+                self._train_text(line)
+
+    # ---------------- 马尔可夫（字符级 n-gram） ----------------
+    def _train_text(self, text):
+        sents = re.split(r'[。！？!?\n；;]', text)
+        for sent in sents:
+            sent = sent.strip()
+            if len(sent) < self.n + 1:
+                continue
+            toks = list(sent)
+            self.starters.append(tuple(toks[:self.n]))
+            for i in range(len(toks) - self.n):
+                key = tuple(toks[i:i + self.n])
+                self.model.setdefault(key, []).append(toks[i + self.n])
+        if sents:
+            self.trained = True
+
+    def _generate(self, seed=None, max_len=40):
+        if not self.trained or not self.starters:
+            return ""
+        key = tuple(seed[-self.n:]) if seed else random.choice(self.starters)
+        if seed and key not in self.model:
+            key = random.choice(self.starters)
+        res = list(key)
+        for _ in range(max_len):
+            if key in self.model and self.model[key]:
+                res.append(random.choice(self.model[key]))
+                key = tuple(res[-self.n:])
+            else:
+                break
+        return "".join(res)
+
+    # ---------------- 检索（字符 bigram 余弦） ----------------
+    @staticmethod
+    def _char_bigrams(s):
+        s = ''.join(re.findall(r'\w', s.lower()))
+        return [s[i:i + 2] for i in range(len(s) - 1)] or [s]
+
+    @staticmethod
+    def _cosine(a, b):
+        sa = DoorCore._char_bigrams(a)
+        sb = DoorCore._char_bigrams(b)
+        va, vb = {}, {}
+        for g in sa:
+            va[g] = va.get(g, 0) + 1
+        for g in sb:
+            vb[g] = vb.get(g, 0) + 1
+        common = set(va) & set(vb)
+        num = sum(va[g] * vb[g] for g in common)
+        da = math.sqrt(sum(v * v for v in va.values()))
+        db = math.sqrt(sum(v * v for v in vb.values()))
+        return num / (da * db) if da and db else 0.0
+
+    def _retrieve(self, text, threshold=0.35):
+        best, best_score, best_q = None, 0.0, None
+        for q, a in self.kb:
+            score = self._cosine(text, q)
+            if q and q in text:
+                score = max(score, 0.95)
+            elif text and text in q and len(text) >= 4:
+                score = max(score, 0.95)
+            if score > best_score:
+                best, best_score, best_q = a, score, q
+        if best_score >= threshold:
+            return best, best_score, best_q
+        return None, best_score, best_q
+
+    # ---------------- 时间 / 意图 ----------------
+    @staticmethod
+    def _is_time_query(t):
+        strong = ['几点', '几号', '星期', '周几', '礼拜', '点钟', '点了',
+                  '什么时间', '什么日期', '几日', '几时']
+        if any(w in t for w in strong):
+            return True
+        weak = ['现在', '今天', '日期']
+        ask = ['几', '什么', '哪', '呢', '？', '?']
+        if any(w in t for w in weak) and any(q in t for q in ask):
+            return True
+        if t in ('现在', '今天', '日期', '今天呢', '现在呢', '时间'):
+            return True
+        return False
+
+    @staticmethod
+    def _time_reply():
+        now = datetime.datetime.now()
+        weekdays = ['星期一', '星期二', '星期三', '星期四', '星期五',
+                    '星期六', '星期日']
+        wd = weekdays[now.weekday()]
+        h = now.hour
+        if 5 <= h < 8:
+            part = '早上'
+        elif 8 <= h < 11:
+            part = '上午'
+        elif 11 <= h < 13:
+            part = '中午'
+        elif 13 <= h < 18:
+            part = '下午'
+        elif 18 <= h < 24:
+            part = '晚上'
+        else:
+            part = '凌晨'
+        return (f"现在是 {now.year}年{now.month}月{now.day}日 "
+                f"{wd} {part}{now.hour}点{now.minute}分{now.second}秒"
+                f"（本机时间）。")
+
+    # ---------------- 寒暄识别 ----------------
+    @staticmethod
+    def _is_greeting(t):
+        if len(t) > 12:
+            return False
+        stripped = t.lower()
+        for k in _GREETING_KEYWORDS:
+            stripped = stripped.replace(k, "")
+        stripped = re.sub(_GREETING_FILLER, "", stripped)
+        return len(stripped) == 0
+
+    # ---------------- 科学计算（安全 eval，仅白名单函数/常数 + 中文算式） ----------------
+    @staticmethod
+    def _calc(t):
+        try:
+            if len(t) > 200:
+                return None
+            expr = (t.translate(str.maketrans('－０１２３４５６７８９，',
+                                              '-0123456789,'))
+                     .replace('（', '(').replace('）', ')')
+                     .replace('％', '%').replace('！', '!').replace('^', '**'))
+            # 中文函数名 -> 英文别名
+            _CN_ALIAS = {
+                '绝对值': 'abs', '开方': 'sqrt', '平方根': 'sqrt', '根号': 'sqrt',
+                '四舍五入': 'round', '取整': 'round', '向下取整': 'floor',
+                '向上取整': 'ceil', '阶乘': 'factorial', '对数': 'log',
+                '常用对数': 'log10', '正弦': 'sin', '余弦': 'cos', '正切': 'tan',
+                '反正弦': 'asin', '反余弦': 'acos', '反正切': 'atan',
+                '双曲正弦': 'sinh', '双曲余弦': 'cosh', '双曲正切': 'tanh',
+                '弧度': 'radians', '角度': 'degrees', '指数': 'exp',
+                '最大': 'max', '最小': 'min', '求和': 'sum',
+                '排列': 'perm', '组合': 'comb',
+                '圆周率': 'pi', '自然常数': 'e',
+            }
+            for k, v in _CN_ALIAS.items():
+                expr = expr.replace(k, v)
+
+            # 中文数字 -> 阿拉伯数字
+            def zh_to_int(s):
+                digits = {'零': 0, '一': 1, '二': 2, '两': 2, '三': 3, '四': 4,
+                          '五': 5, '六': 6, '七': 7, '八': 8, '九': 9}
+                units = {'十': 10, '百': 100, '千': 1000}
+                if '万' in s:
+                    a, _, b = s.partition('万')
+                    left = zh_to_int(a) if a else 0
+                    right = zh_to_int(b) if b else 0
+                    return (left or 0) * 10000 + (right or 0)
+                num, section = 0, 0
+                for ch in s:
+                    if ch in digits:
+                        section = digits[ch]
+                    elif ch in units:
+                        u = units[ch]
+                        if section == 0:
+                            section = 1
+                        num += section * u
+                        section = 0
+                    else:
+                        return None
+                return num + section
+
+            def _repl_cn(m):
+                v = zh_to_int(m.group(0))
+                return str(v) if v is not None else m.group(0)
+
+            expr = re.sub(r'[零一二两三四五六七八九十百千万]+', _repl_cn, expr)
+            # 的……次方 / 次幂
+            expr = re.sub(r'([0-9A-Za-z_]+)\s*的\s*'
+                          r'([+-]?[0-9]+\.?[0-9]*)\s*次方', r'pow(\1,\2)', expr)
+            expr = re.sub(r'([0-9A-Za-z_]+)\s*的\s*'
+                          r'([+-]?[0-9]+\.?[0-9]*)\s*次幂', r'pow(\1,\2)', expr)
+            # 一元函数：abs(5) / 5的绝对值 / sqrt16
+            _UNARY = ('abs', 'sqrt', 'round', 'floor', 'ceil', 'log', 'log10',
+                      'log2', 'sin', 'cos', 'tan', 'exp', 'factorial', 'gcd',
+                      'hypot', 'radians', 'degrees', 'min', 'max')
+            for en in _UNARY:
+                expr = re.sub(r'(?<![0-9A-Za-z])' + en + r'\s*'
+                              r'([+-]?[0-9]+\.?[0-9]*)', en + r'(\1)', expr)
+            expr = re.sub(r'(?<![0-9A-Za-z])([+-]?[0-9]+\.?[0-9]*)\s*的\s*'
+                          r'(abs|sqrt|round|floor|ceil|log|log10|log2|sin|cos|'
+                          r'tan|exp|factorial|gcd|hypot|radians|degrees|min|max)',
+                          r'\2(\1)', expr)
+            expr = re.sub(r'(?<![0-9A-Za-z])([+-]?[0-9]+\.?[0-9]*)\s*'
+                          r'(abs|sqrt|round|floor|ceil|log|log10|log2|sin|cos|'
+                          r'tan|exp|factorial|gcd|hypot|radians|degrees|min|max)'
+                          r'(?![0-9A-Za-z])', r'\2(\1)', expr)
+            # 平方 / 立方（含「X的平方」「X的立方」）
+            expr = re.sub(r'([0-9)])\s*的\s*平方', r'\1**2', expr)
+            expr = re.sub(r'([0-9)])\s*的\s*立方', r'\1**3', expr)
+            expr = re.sub(r'([0-9)])\s*平方', r'\1**2', expr)
+            expr = re.sub(r'([0-9)])\s*立方', r'\1**3', expr)
+            # 阶乘
+            expr = re.sub(r'(\d+|\([^()]*\))\s*!', r'factorial(\1)', expr)
+            # 中文运算符
+            expr = expr.replace('×', '*').replace('÷', '/')
+            expr = expr.replace('加上', '+').replace('加', '+')
+            expr = expr.replace('减去', '-').replace('减', '-')
+            expr = expr.replace('乘以', '*').replace('乘', '*')
+            expr = expr.replace('除以', '/').replace('除', '/')
+            # 从混杂中文的句子里抠出最长的合法算式串（吃掉“等于几/是多少”等问词）
+            cands = re.findall(r'[0-9A-Za-z_().+\-*/%,\s]+', expr)
+            if not cands:
+                return None
+            expr = max(cands, key=len).strip()
+            if not re.fullmatch(r'[0-9A-Za-z_().+\-*/%,\s]+', expr):
+                return None
+            val = eval(expr, {"__builtins__": {}}, _SAFE_MATH)
+            if isinstance(val, (int, float, complex)):
+                if isinstance(val, float) and val.is_integer():
+                    val = int(val)
+                return f"{expr} = {val}"
+            return None
+        except Exception:
+            return None
+
+    # ---------------- 角色扮演：后缀应用 ----------------
+    def _apply_role(self, text):
+        if not self.role:
+            return text
+        cfg = ROLES.get(self.role)
+        if not cfg:
+            return text
+        suf = cfg.get("suffix", "")
+        if not suf:
+            return text
+        out = re.sub(r'([。！？!?])', r'\1' + suf, text)
+        if not out.endswith(suf):
+            out = out + suf
+        return out
+
+    # ---------------- 统一回复接口 ----------------
+    def ask(self, text, threshold=0.35):
+        text = (text or "").strip()
+        if not text:
+            return "在的，你说～"
+        # 退出角色
+        if any(w in text for w in ("退出角色", "退出扮演", "正常模式",
+                                   "关闭角色", "取消扮演", "变回正常")):
+            self.role = None
+            return "已退出角色扮演，恢复正常模式～"
+        # 进入角色（触发词本句当作指令，直接确认切换，不拿它当问题回答）
+        for name, cfg in ROLES.items():
+            if any(trig in text for trig in cfg["triggers"]):
+                self.role = name
+                return self._apply_role("喵～已经变成猫娘啦，以后每句话我都会带喵哦！")
+        # 寒暄
+        if self._is_greeting(text):
+            return self._apply_role(random.choice(_GREETING_REPLIES))
+        # 数学
+        r = self._calc(text)
+        if r is not None:
+            return self._apply_role(r)
+        # 时间
+        if self._is_time_query(text):
+            return self._apply_role(self._time_reply())
+        # 知识库检索
+        ans, score, q = self._retrieve(text, threshold)
+        if ans:
+            return self._apply_role(ans)
+        # 马尔可夫兜底
+        gen = self._generate(seed=text, max_len=40)
+        if gen and len(gen) >= 2:
+            return self._apply_role(gen)
+        return self._apply_role("这个我还没学会耶～你可以把答案写进语料库"
+                                "（用 问题===答案 的格式）教我，或者换个说法试试。")
+
+    # ---------------- 持久化（训练结果存盘，启动秒开） ----------------
+    def save_model(self, path=None):
+        path = path or self.model_path
+        if not path:
+            return
+        data = {
+            "n": self.n,
+            "model": self.model,
+            "starters": self.starters,
+            "kb": self.kb,
+        }
+        tmp = path + ".tmp"
+        with open(tmp, "wb") as f:
+            pickle.dump(data, f, protocol=pickle.HIGHEST_PROTOCOL)
+        os.replace(tmp, path)
+
+    def load_model(self, path=None):
+        path = path or self.model_path
+        if not path or not os.path.exists(path):
+            return False
+        try:
+            with open(path, "rb") as f:
+                data = pickle.load(f)
+            self.n = data.get("n", self.n)
+            self.model = data.get("model", {})
+            self.starters = data.get("starters", [])
+            self.kb = data.get("kb", [])
+            self.trained = bool(self.model or self.kb)
+            return True
+        except Exception:
+            return False
+
+    def load_or_train(self, force=False):
+        if not force and self.load_model():
+            return "loaded"
+        self.load_corpus()
+        self.save_model()
+        return "trained"

doorcore/data/config.json

@@ -0,0 +1,3 @@
+{
+  "n": 3
+}