knowledge-graph-kit 0.1.0__py3-none-any.whl

knowledge_graph_kit/__init__.py

@@ -0,0 +1,42 @@
+"""knowledge-graph-kit: 知识图谱构建管线。
+
+提供从文本分块、LLM 抽取、实体解析到 Neo4j 写入的完整管线。
+"""
+
+__version__ = "0.1.0"
+
+from .chunker import Chunk, SectionChunker, chunk_file
+from .entity_resolver import (
+    clean_properties,
+    dedup_exact,
+    fuzzy_align,
+    resolve,
+)
+from .extractor import (
+    Entity,
+    ExtractionResult,
+    Relation,
+    build_system_prompt,
+    extract_from_chunk,
+    merge_results,
+    parse_schema,
+)
+from .neo4j_writer import Neo4jWriter
+
+__all__ = [
+    "Chunk",
+    "SectionChunker",
+    "chunk_file",
+    "Entity",
+    "Relation",
+    "ExtractionResult",
+    "parse_schema",
+    "build_system_prompt",
+    "extract_from_chunk",
+    "merge_results",
+    "dedup_exact",
+    "clean_properties",
+    "fuzzy_align",
+    "resolve",
+    "Neo4jWriter",
+]

knowledge_graph_kit/chunker.py

@@ -0,0 +1,252 @@
+"""
+chunker.py — Section-Aware Chunking
+
+从教材 txt 文件读取内容，按多级标题（2.1 / 2.1.1 / ...）拆分为语义块，
+每个 Chunk 保留层级元数据，供后续 LLM 抽取实体和关系。
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+# Windows 终端 UTF-8 支持
+if sys.platform == "win32":
+    try:
+        sys.stdout.reconfigure(encoding="utf-8")  # type: ignore[attr-defined]
+    except Exception:
+        pass
+
+
+# ── 正则 ────────────────────────────────────────────────────
+# 匹配 "2.1 基本语法"、"2.1.1标识符"（标题前可有空格也可无空格）
+SECTION_RE = re.compile(r"^(\d+)\.(\d+)(?:\.(\d+))?\s*(.+)$")
+# 匹配 "第2章 ES基础"
+CHAPTER_RE = re.compile(r"^第(\d+)章\s+(.+)$")
+# 匹配 "【示例2-1】" 或 "【示例2-10】"
+EXAMPLE_RE = re.compile(r"【示例(\d+)-(\d+)】")
+# 匹配 "表2-1" 或 "表2-10"
+TABLE_RE = re.compile(r"表(\d+)-(\d+)")
+
+
+# ── 数据结构 ────────────────────────────────────────────────
+
+@dataclass
+class Chunk:
+    """一个语义块"""
+    chunk_id: str               # "2.1" / "2.1.1"
+    title: str                  # "基本语法" / "标识符"
+    level: int                  # 0=章, 1=节, 2=子节
+    parent_id: Optional[str]    # "2" 或 "2.1"
+    text: str                   # 块内容（不含标题行自身）
+    lines: tuple[int, int]      # (start_line, end_line) 1-indexed
+    examples: list[str] = field(default_factory=list)  # ["2-1", "2-2"]
+    tables: list[str] = field(default_factory=list)    # ["2-1", "2-2"]
+    has_code: bool = False      # 是否包含代码示例
+
+
+# ── 分块器 ──────────────────────────────────────────────────
+
+class SectionChunker:
+    """按教材章节层级拆分语义块"""
+
+    def __init__(self, text: str):
+        self.lines = text.splitlines()
+        self._chunks: list[Chunk] = []
+
+    def chunk(self) -> list[Chunk]:
+        """执行分块，返回 Chunk 列表"""
+        self._chunks = []
+        boundaries = self._find_section_boundaries()
+
+        for i, (start, end) in enumerate(boundaries):
+            header_line = self.lines[start]
+            chunk = self._build_chunk(header_line, start, end, boundaries)
+
+            # 章标题使用特殊 ID
+            if chunk.level == 0:
+                chunk.chunk_id = f"ch{chunk.chunk_id}"
+
+            # 提取块内的示例和表格引用
+            body = "\n".join(self.lines[start + 1 : end])
+            chunk.examples = EXAMPLE_RE.findall(body)
+            chunk.tables = TABLE_RE.findall(body)
+            chunk.has_code = "```" in body or "<script>" in body
+
+            self._chunks.append(chunk)
+
+        return self._chunks
+
+    # ── 内部方法 ────────────────────────────────────────────
+
+    def _find_section_boundaries(self) -> list[tuple[int, int]]:
+        """找出所有标题行及其对应的行号区间"""
+        headers: list[tuple[int, int, str]] = []  # (line_no, level, title_text)
+
+        for idx, line in enumerate(self.lines):
+            # 尝试匹配章标题
+            m = CHAPTER_RE.match(line)
+            if m:
+                headers.append((idx, 0, line.strip()))
+                continue
+
+            # 尝试匹配节/子节标题
+            m = SECTION_RE.match(line)
+            if m:
+                # 判断层级
+                if m.group(3) is not None:  # 2.1.1 → level 2
+                    level = 2
+                else:
+                    level = 1
+                headers.append((idx, level, line.strip()))
+
+        # 转换成 (start, end) 区间
+        boundaries: list[tuple[int, int]] = []
+        for i, (start, _, _) in enumerate(headers):
+            end = headers[i + 1][0] if i + 1 < len(headers) else len(self.lines)
+            boundaries.append((start, end))
+
+        return boundaries
+
+    def _build_chunk(
+        self,
+        header_line: str,
+        start: int,
+        end: int,
+        boundaries: list[tuple[int, int]],
+    ) -> Chunk:
+        """从标题行和行区间构建 Chunk"""
+        # 提取层级信息
+        cm = CHAPTER_RE.match(header_line)
+        if cm:
+            ch_num = cm.group(1)
+            title = cm.group(2)
+            # 找前一个 header 作为 parent
+            parent_id = None
+            for s, _ in boundaries:
+                h = self.lines[s]
+                sm = SECTION_RE.match(h)
+                if sm and sm.group(1) == ch_num and sm.group(3) is None:
+                    parent_id = sm.group(1)
+                    break
+            return Chunk(
+                chunk_id=ch_num,
+                title=title,
+                level=0,
+                parent_id=parent_id,
+                text="\n".join(self.lines[start + 1 : end]),
+                lines=(start + 1, end),
+            )
+
+        sm = SECTION_RE.match(header_line)
+        if sm:
+            major = sm.group(1)
+            minor = sm.group(2)
+            sub = sm.group(3)  # None 表示 level 1
+            title = sm.group(4).strip()
+
+            if sub is None:
+                # Level 1: "2.1 基本语法"
+                chunk_id = f"{major}.{minor}"
+                parent_id = f"ch{major}"
+                level = 1
+            else:
+                # Level 2: "2.1.1 标识符"
+                chunk_id = f"{major}.{minor}.{sub}"
+                parent_id = f"{major}.{minor}"
+                level = 2
+
+            return Chunk(
+                chunk_id=chunk_id,
+                title=title,
+                level=level,
+                parent_id=parent_id,
+                text="\n".join(self.lines[start + 1 : end]),
+                lines=(start + 1, end),
+            )
+
+        # 兜底（理论上不会走到这里）
+        return Chunk(
+            chunk_id="unknown",
+            title=header_line.strip(),
+            level=-1,
+            parent_id=None,
+            text="\n".join(self.lines[start + 1 : end]),
+            lines=(start + 1, end),
+        )
+
+
+# ── 入口 ────────────────────────────────────────────────────
+
+def chunk_file(txt_path: str | Path) -> list[Chunk]:
+    """读取 txt 文件并分块"""
+    txt_path = Path(txt_path)
+    if not txt_path.exists():
+        raise FileNotFoundError(f"文件未找到: {txt_path}")
+
+    text = txt_path.read_text(encoding="utf-8")
+    chunker = SectionChunker(text)
+    return chunker.chunk()
+
+
+def safe_print(text: str = "", **kwargs):
+    """安全打印，避免 Windows GBK 编码问题"""
+    try:
+        print(text, **kwargs)
+    except UnicodeEncodeError:
+        print(text.encode("utf-8", errors="replace").decode("utf-8", errors="replace"), **kwargs)
+
+
+def print_summary(chunks: list[Chunk]) -> None:
+    """打印分块摘要（用于验证）"""
+    safe_print(f"\n{'='*60}")
+    safe_print(f"共 {len(chunks)} 个 Chunk")
+    safe_print(f"{'='*60}\n")
+    for c in chunks:
+        line_info = f"L{c.lines[0]}-{c.lines[1]}"
+        parent = f" ← {c.parent_id}" if c.parent_id else ""
+        tags = []
+        if c.examples:
+            tags.append(f"示例:{len(c.examples)}")
+        if c.tables:
+            tags.append(f"表格:{len(c.tables)}")
+        if c.has_code:
+            tags.append("含代码")
+        tag_str = f"  [{', '.join(tags)}]" if tags else ""
+        text_preview = c.text[:60].replace("\n", " ")
+        safe_print(f"  [{c.chunk_id}] (level={c.level}) {line_info}{parent}")
+        safe_print(f"     标题: {c.title}")
+        safe_print(f"     预览: {text_preview}...{tag_str}")
+        safe_print()
+
+
+# ── CLI ─────────────────────────────────────────────────────
+
+def main(argv: list[str] | None = None) -> None:
+    """CLI 入口：分块文本文件并打印摘要。
+
+    用法: kg-chunker <txt_path>
+          kg-chunker （使用 KG_CHUNKER_INPUT 环境变量）
+    """
+    if argv is None:
+        argv = sys.argv[1:]
+
+    if len(argv) >= 1:
+        txt_path = argv[0]
+    elif os.environ.get("KG_CHUNKER_INPUT"):
+        txt_path = os.environ["KG_CHUNKER_INPUT"]
+    else:
+        print("用法: kg-chunker <txt_path>", file=sys.stderr)
+        print("      或设置 KG_CHUNKER_INPUT 环境变量", file=sys.stderr)
+        sys.exit(1)
+
+    chunks = chunk_file(txt_path)
+    print_summary(chunks)
+
+
+if __name__ == "__main__":
+    main()

knowledge_graph_kit/entity_resolver.py

@@ -0,0 +1,393 @@
+"""
+entity_resolver.py — 实体对齐去重
+
+策略：
+  1. 精确去重：合并 (name, type) 完全相同的实体
+  2. 模糊对齐：用 LLM 判断名称近似但字面不同的实体是否同一概念
+  3. 关系更新：去重后更新关系中引用的实体名称
+  4. 干净输出：清理 null 属性值
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+from openai import OpenAI
+
+if sys.platform == "win32":
+    try:
+        sys.stdout.reconfigure(encoding="utf-8")  # type: ignore[attr-defined]
+    except Exception:
+        pass
+
+# ── 惰性客户端 ────────────────────────────────────────────────
+_client_instance: OpenAI | None = None
+_http_client_instance: httpx.Client | None = None
+_MODEL: str = "gpt-4o-mini"
+
+
+def configure(api_key: str, base_url: str | None = None, model: str = "gpt-4o-mini") -> None:
+    """显式配置 OpenAI 客户端（在程序化使用时调用）。"""
+    global _client_instance, _http_client_instance, _MODEL
+    import httpx
+    _http_client_instance = httpx.Client(verify=True, follow_redirects=True)
+    _client_instance = OpenAI(api_key=api_key, base_url=base_url, http_client=_http_client_instance, timeout=30)
+    _MODEL = model
+
+
+def _get_client() -> OpenAI:
+    """惰性初始化 OpenAI 客户端，从环境变量读取配置。"""
+    global _client_instance, _http_client_instance, _MODEL
+    if _client_instance is None:
+        api_key = os.getenv("OPENAI_API_KEY", "")
+        if not api_key:
+            raise RuntimeError(
+                "OPENAI_API_KEY 未设置。请在 .env 中配置或调用 configure()。"
+            )
+        base_url = os.getenv("OPENAI_BASE_URL")
+        model = os.getenv("LLM_MODEL_NAME", "gpt-4o-mini")
+        import httpx
+        _http_client_instance = httpx.Client(verify=True, follow_redirects=True)
+        _client_instance = OpenAI(api_key=api_key, base_url=base_url, http_client=_http_client_instance, timeout=30)
+        _MODEL = model
+    return _client_instance
+
+
+# ═══════════════════════════════════════════════════════════
+# 1. 精确去重
+# ═══════════════════════════════════════════════════════════
+
+def dedup_exact(entities: list[dict]) -> list[dict]:
+    """基于 (name, type) 精确合并，相同 key 的实体合并属性"""
+    merged: dict[tuple[str, str], dict] = {}
+    for e in entities:
+        key = (e["name"].strip(), e["type"].strip())
+        if key in merged:
+            # 合并属性：后出现的覆盖前面的 null
+            existing = merged[key]
+            for k, v in e.get("properties", {}).items():
+                if v is not None:
+                    existing.setdefault("properties", {})[k] = v
+            # 如果现有属性是 null 则用新值填充
+            for k, v in list(existing.get("properties", {}).items()):
+                if v is None and k in e.get("properties", {}):
+                    existing["properties"][k] = e["properties"][k]
+        else:
+            merged[key] = dict(e)  # shallow copy
+
+    return list(merged.values())
+
+
+# ═══════════════════════════════════════════════════════════
+# 2. 属性清理
+# ═══════════════════════════════════════════════════════════
+
+def clean_properties(entities: list[dict]) -> list[dict]:
+    """去掉值为 null 的属性"""
+    for e in entities:
+        if "properties" in e and e["properties"]:
+            e["properties"] = {k: v for k, v in e["properties"].items() if v is not None}
+    return entities
+
+
+# ═══════════════════════════════════════════════════════════
+# 3. 模糊对齐（LLM 判断）
+# ═══════════════════════════════════════════════════════════
+
+def _find_fuzzy_candidates(entities: list[dict]) -> list[tuple[int, int, str]]:
+    """找出名称相似的候选对（同类型或相关类型的跨类型候选）"""
+    candidates = []
+    by_type: dict[str, list[tuple[int, str]]] = {}
+    for i, e in enumerate(entities):
+        t = e["type"]
+        by_type.setdefault(t, []).append((i, e["name"]))
+
+    # 可跨类型比较的组（Topic/Concept/Skill 可互相转换）
+    cross_groups = [{"Topic", "Concept", "Skill"}]
+
+    # 同类型比较
+    for t, items in by_type.items():
+        for a_idx, a_name in items:
+            for b_idx, b_name in items:
+                if b_idx <= a_idx:
+                    continue
+                if t == "CodeExample":
+                    continue
+                if _name_similar(a_name, b_name) > 0.5:
+                    candidates.append((a_idx, b_idx, t))
+
+    # 跨类型比较（Topic/Concept/Skill 之间）
+    for group in cross_groups:
+        all_items = []
+        for t in group:
+            all_items.extend(by_type.get(t, []))
+        for a_idx, a_name in all_items:
+            for b_idx, b_name in all_items:
+                if b_idx <= a_idx:
+                    continue
+                if entities[a_idx]["type"] == entities[b_idx]["type"]:
+                    continue  # 已在同类型中处理过
+                if _name_similar(a_name, b_name) > 0.5:
+                    candidates.append((a_idx, b_idx, f"{entities[a_idx]['type']}/{entities[b_idx]['type']}"))
+
+    return candidates
+
+
+def _name_similar(a: str, b: str) -> float:
+    """基于字符集合的简单名称相似度"""
+    if not a or not b:
+        return 0.0
+    a_chars, b_chars = set(a), set(b)
+    if not a_chars or not b_chars:
+        return 0.0
+    intersection = a_chars & b_chars
+    return 2 * len(intersection) / (len(a_chars) + len(b_chars))
+
+
+def fuzzy_align(entities: list[dict], client: OpenAI | None = None) -> list[dict]:
+    """用 LLM 判断模糊候选对是否同义，合并如果同义"""
+    candidates = _find_fuzzy_candidates(entities)
+    if not candidates:
+        print("  ℹ️  无可模糊对齐的候选对")
+        return entities
+
+    print(f"  🔍 发现 {len(candidates)} 个模糊候选对，正在用 LLM 判断...")
+
+    # 构建合并图：找到同义实体组
+    uf = _UnionFind(len(entities))
+    for a_idx, b_idx, etype in candidates:
+        if _judge_same(entities[a_idx]["name"], entities[b_idx]["name"], etype, client=client) == "same":
+            uf.union(a_idx, b_idx)
+            print(f"    ✅ 同义: '{entities[a_idx]['name']}' ≈ '{entities[b_idx]['name']}'")
+
+    # 按组聚合
+    groups: dict[int, list[int]] = {}
+    for i in range(len(entities)):
+        root = uf.find(i)
+        groups.setdefault(root, []).append(i)
+
+    merged_count = sum(len(indices) - 1 for indices in groups.values())
+    if merged_count == 0:
+        print("  ℹ️  无实际合并")
+        return entities
+
+    # 每组保留一个最佳实体，合并属性
+    result = []
+    for root, indices in groups.items():
+        if len(indices) == 1:
+            result.append(dict(entities[indices[0]]))
+            continue
+
+        # 找到最佳保留者
+        best = min(indices, key=lambda i: (
+            {"Concept": 0, "Skill": 1, "Topic": 2, "CodeExample": 3, "TextSegment": 4, "Question": 5}.get(entities[i]["type"], 9),
+            len(entities[i]["name"]),
+        ))
+        survivor = dict(entities[best])
+        # 合并其他实体的属性
+        for i in indices:
+            if i == best:
+                continue
+            print(f"      → 合并 '{entities[i]['name']}'({entities[i]['type']}) 到 '{entities[best]['name']}'")
+            for k, v in entities[i].get("properties", {}).items():
+                if v is not None and (k not in survivor.get("properties", {}) or survivor["properties"].get(k) is None):
+                    survivor.setdefault("properties", {})[k] = v
+        result.append(survivor)
+
+    print(f"    📊 合并完成: {len(entities)} → {len(result)}")
+    return result
+
+
+class _UnionFind:
+    """并查集，用于合并同义实体组"""
+    def __init__(self, n: int):
+        self.parent = list(range(n))
+    def find(self, x: int) -> int:
+        while self.parent[x] != x:
+            self.parent[x] = self.parent[self.parent[x]]
+            x = self.parent[x]
+        return x
+    def union(self, a: int, b: int) -> None:
+        ra, rb = self.find(a), self.find(b)
+        if ra != rb:
+            self.parent[ra] = rb
+
+
+def _judge_same(name_a: str, name_b: str, etype: str, client: OpenAI | None = None) -> str:
+    """调用 LLM 判断两个名称是否指向同一实体"""
+    llm_client = client or _get_client()
+    prompt = f"""判断以下两个实体名称在教材知识图谱中是否指向**同一个概念**。
+
+实体类型: {etype}
+名称 A: {name_a}
+名称 B: {name_b}
+
+规则：
+- 如果 A 和 B 是同一概念的不同表述（如 "箭头函数" 和 "arrow function"），回答 "same"
+- 如果是不同的概念，回答 "different"
+- 只回答 same 或 different，不要解释"""
+
+    try:
+        resp = llm_client.chat.completions.create(
+            model=_MODEL,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.0,
+            max_tokens=10,
+        )
+        answer = resp.choices[0].message.content.strip().lower()
+        return "same" if answer == "same" else "different"
+    except Exception:
+        return "different"
+
+
+def _pick_canonical(a_idx: int, b_idx: int, entities: list[dict]) -> tuple[int, int]:
+    """选择更规范的名称（更具体的类型优先，其次短名）"""
+    a = entities[a_idx]
+    b = entities[b_idx]
+    # 优先级：Concept > Skill > Topic（越具体越好）
+    type_order = {"Concept": 0, "Skill": 1, "Topic": 2, "CodeExample": 3}
+    a_score = type_order.get(a["type"], 5)
+    b_score = type_order.get(b["type"], 5)
+
+    if a_score < b_score:
+        return a_idx, b_idx
+    if b_score < a_score:
+        return b_idx, a_idx
+
+    # 同类型：保留短名（更可能是规范术语）
+    if len(a["name"]) <= len(b["name"]):
+        return a_idx, b_idx
+    return b_idx, a_idx
+
+
+# ═══════════════════════════════════════════════════════════
+# 4. 关系更新
+# ═══════════════════════════════════════════════════════════
+
+def update_relations(
+    relations: list[dict],
+    entities: list[dict],
+    old_entities: list[dict],
+) -> list[dict]:
+    """去重后更新关系中的实体名称引用（如果实体名称变了）"""
+    # 构建旧名称→新名称的映射（仅当名称在合并中被规范化时）
+    name_map: dict[str, str] = {}
+    old_names = {(e["name"], e["type"]) for e in old_entities}
+    new_names = {(e["name"], e["type"]) for e in entities}
+
+    for oe in old_entities:
+        key = (oe["name"], oe["type"])
+        if key not in new_names:
+            # 该实体被合并了，找到新名称
+            for ne in entities:
+                if ne["type"] == oe["type"] and (
+                    ne["name"] in oe["name"] or oe["name"] in ne["name"]
+                ):
+                    name_map[oe["name"]] = ne["name"]
+                    break
+
+    if not name_map:
+        return relations
+
+    updated = []
+    for rel in relations:
+        nr = dict(rel)
+        if nr["source"] in name_map:
+            nr["source"] = name_map[nr["source"]]
+        if nr["target"] in name_map:
+            nr["target"] = name_map[nr["target"]]
+        updated.append(nr)
+
+    return updated
+
+
+# ═══════════════════════════════════════════════════════════
+# 5. 完整去重管线
+# ═══════════════════════════════════════════════════════════
+
+def resolve(entities: list[dict], relations: list[dict], skip_fuzzy: bool = True) -> tuple[list[dict], list[dict]]:
+    """完整实体对齐去重管线"""
+    old_entities = list(entities)
+
+    # 步骤 1: 精确去重
+    entities = dedup_exact(entities)
+    print(f"  📊 精确去重: {len(old_entities)} → {len(entities)}")
+
+    # 步骤 2: 属性清理
+    entities = clean_properties(entities)
+    print(f"  🧹 属性清理完成")
+
+    # 步骤 3: 模糊对齐（默认跳过，避免大量 LLM 调用）
+    if not skip_fuzzy:
+        entities = fuzzy_align(entities)
+        print(f"  🎯 模糊对齐后: {len(entities)} 个实体")
+    else:
+        print(f"  ⏭️  跳过模糊对齐（设置 SKIP_FUZZY=false 可启用）")
+
+    # 步骤 4: 更新关系
+    relations = update_relations(relations, entities, old_entities)
+    print(f"  🔗 关系更新: {len(relations)} 条")
+
+    return entities, relations
+
+
+# ═══════════════════════════════════════════════════════════
+# 6. CLI
+# ═══════════════════════════════════════════════════════════
+
+def main(argv: list[str] | None = None) -> None:
+    """CLI 入口：实体对齐去重。
+
+    用法: kg-resolver <input.json>
+          kg-resolver （使用 KG_RESOLVER_INPUT / KG_RESOLVER_OUTPUT 环境变量）
+    """
+    if argv is None:
+        argv = sys.argv[1:]
+
+    from dotenv import load_dotenv
+    load_dotenv()
+
+    if len(argv) >= 1:
+        src_path = Path(argv[0])
+    elif os.environ.get("KG_RESOLVER_INPUT"):
+        src_path = Path(os.environ["KG_RESOLVER_INPUT"])
+    else:
+        print("用法: kg-resolver <input.json>", file=sys.stderr)
+        print("      或设置 KG_RESOLVER_INPUT 环境变量", file=sys.stderr)
+        sys.exit(1)
+
+    if not src_path.exists():
+        print(f"❌ 未找到提取结果: {src_path}")
+        sys.exit(1)
+
+    data = json.loads(src_path.read_text(encoding="utf-8"))
+    entities: list[dict] = data["entities"]
+    relations: list[dict] = data["relations"]
+
+    print(f"📥 加载: {len(entities)} 实体, {len(relations)} 关系")
+
+    skip_fuzzy = os.environ.get("SKIP_FUZZY", "true").lower() in ("true", "1", "yes")
+    entities, relations = resolve(entities, relations, skip_fuzzy=skip_fuzzy)
+
+    # 保存结果
+    output = {
+        "entities": entities,
+        "relations": relations,
+    }
+    out_path_str = os.environ.get("KG_RESOLVER_OUTPUT", "extraction_result_clean.json")
+    out_path = Path(out_path_str)
+    out_path.write_text(
+        json.dumps(output, indent=2, ensure_ascii=False),
+        encoding="utf-8",
+    )
+    print(f"\n✅ 已保存: {out_path}")
+    print(f"   实体: {len(entities)} 个, 关系: {len(relations)} 条")
+
+
+if __name__ == "__main__":
+    main()