mcai-knowledge 0.2.0__py3-none-any.whl

mcai/pipeline.py

@@ -0,0 +1,47 @@
+"""构建流水线：语料 → 知识库 → 静态站 → 数据集。"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from . import dashboard, dataset, site
+from .corpus import load_corpus, load_config
+from .disambig import load as load_disambig
+from .extract import build
+
+
+def rebuild(root: str | Path) -> dict:
+    root = Path(root).resolve()
+    corpus = load_corpus(root / "config" / "corpus.json")
+    curated = load_config(root / "config" / "curated.json")
+    overrides_path = root / "config" / "overrides.json"
+    overrides = load_config(overrides_path) if overrides_path.exists() else {}
+    disambig = load_disambig(root / "config" / "disambiguation.json")
+    kb = build(corpus, curated, overrides, disambig)
+
+    kb.save(root / "data" / "kb.json")
+    pages = site.build_site(kb, root / "dist")
+    files = dataset.export(kb, root / "dist" / "dataset")
+    try:
+        dashboard.render(root)
+    except Exception:  # noqa: BLE001 - 看板失败不影响构建
+        pass
+
+    return {
+        "ok": True,
+        "concepts": kb.stats["concepts"],
+        "faqs": kb.stats["faqs"],
+        "relations": kb.stats["relations"],
+        "pages": pages["pages"],
+        "dataset": files,
+        "built_at": kb.built_at,
+        "conflicts": [c.term for c in kb.concepts if c.status == "conflict"],
+        "coverage_missing": kb.stats["coverage"]["missing"],
+    }
+
+
+def load_kb(root: str | Path) -> dict:
+    path = Path(root) / "data" / "kb.json"
+    if not path.exists():
+        rebuild(root)
+    return json.loads(path.read_text(encoding="utf-8"))

mcai/probe.py

@@ -0,0 +1,230 @@
+"""抽检器：测量「模型是否自发知道这套学说」，以及知识注入能带来多少提升。
+
+两类条件对照：
+- baseline：不给任何资料，看模型从训练记忆里能说出多少；
+- grounded：注入知识库检索到的定义与引证，看回答质量变化。
+
+评分不依赖人工：术语命中 + 与标准答案的字二元组覆盖率。
+"""
+from __future__ import annotations
+
+import json
+import re
+from datetime import datetime
+from pathlib import Path
+
+from .knowledge import Knowledge
+from .llm import LLM
+
+CORE_ORDER = [
+    "元意识", "观测创造实在", "现象时空", "元态能量", "序生智能体",
+    "元识", "元知", "元灵", "元子", "本体", "序生", "序生体",
+]
+
+BASELINE_SYSTEM = "你是一位乐于助人的通用助手。请直接、简洁地回答用户问题。"
+GROUNDED_SYSTEM = (
+    "你是「元意识学说」的知识助手。只能依据下面提供的资料回答，不要引入资料之外的理论；"
+    "若资料不足，请明确说明「资料未涉及」。回答控制在 300 字以内。\n\n资料：\n{context}"
+)
+
+
+def _bigrams(text: str) -> set[str]:
+    s = re.sub(r"[\s，。、；：！？\u201c\u201d（）()《》【】\[\]…—\-]", "", text or "")
+    return {s[i: i + 2] for i in range(len(s) - 1)} if len(s) > 1 else {s}
+
+
+def build_questions(kb: Knowledge, limit: int = 12) -> list[dict]:
+    out: list[dict] = []
+    seen: set[str] = set()
+
+    def add(kind: str, question: str, terms: list[str], reference: str) -> None:
+        key = re.sub(r"\s", "", question)
+        if key in seen or not reference:
+            return
+        seen.add(key)
+        out.append({
+            "id": f"q{len(out) + 1}",
+            "kind": kind,
+            "question": question,
+            "terms": [t for t in terms if t],
+            "reference": reference,
+        })
+
+    faqs_by_kind: dict[str, list[dict]] = {}
+    for f in kb.faqs:
+        faqs_by_kind.setdefault(f["kind"], []).append(f)
+
+    definition_faqs = {next((t for t in f.get("source_terms") or []), ""): f
+                       for f in faqs_by_kind.get("definition", [])}
+    for term in CORE_ORDER:
+        f = definition_faqs.get(term)
+        if f:
+            add("definition", f["question"], [term], f["answer"])
+
+    for f in faqs_by_kind.get("contrast", [])[:3]:
+        add("contrast", f["question"], f.get("source_terms") or [], f["answer"])
+
+    for f in faqs_by_kind.get("curated", [])[:3]:
+        add("curated", f["question"], f.get("source_terms") or ["元意识"], f["answer"])
+
+    relation_added = 0
+    for concept in kb.concepts:
+        if relation_added >= 2:
+            break
+        for rel in concept.get("relations") or []:
+            if rel["type"] == "提及" or not rel.get("target_id"):
+                continue
+            question = f"{concept['term']}和{rel['target']}是什么关系？"
+            reference = kb.answer(question).get("answer", "")
+            if reference and "没有直接记录" not in reference:
+                add("relation", question, [concept["term"], rel["target"]], reference)
+                relation_added += 1
+                break
+
+    return out[:limit]
+
+
+def build_context(kb: Knowledge, question: str) -> str:
+    answer = kb.answer(question)
+    parts: list[str] = []
+    if answer.get("type") == "concept":
+        concept = kb.by_term.get(answer.get("term", ""))
+        if concept:
+            parts.append(f"【{concept['term']}】{concept['definition']}")
+            for ev in (concept.get("evidence") or [])[:2]:
+                parts.append(f"原文（{ev['doc_title']}）：「{ev['quote']}」")
+            related = "、".join(r["target"] for r in (concept.get("relations") or [])[:5])
+            if related:
+                parts.append(f"相关概念：{related}")
+    elif answer.get("type") == "faq":
+        parts.append(answer["answer"])
+        for item in answer.get("related") or []:
+            concept = kb.by_slug.get(item.get("slug", ""))
+            if concept:
+                parts.append(f"【{concept['term']}】{concept['definition']}")
+    elif answer.get("type") == "relation":
+        parts.append(answer["answer"])
+    else:
+        for hit in kb.search(question, limit=2):
+            concept = kb.by_slug.get(hit["slug"])
+            if concept:
+                parts.append(f"【{concept['term']}】{concept['definition']}")
+    return "\n".join(parts)[:1800]
+
+
+def score(answer: str, reference: str, terms: list[str],
+          kb_terms: list[str] | None = None) -> dict:
+    """对齐率看「是否说出了标准答案的实质」，术语密度看「是否在用这套词汇」。"""
+    mention = any(t in answer for t in terms)
+    ref_grams = _bigrams(reference)
+    ans_grams = _bigrams(answer)
+    coverage = len(ref_grams & ans_grams) / max(1, len(ref_grams))
+    kb_hits = sum(1 for t in (kb_terms or []) if t in answer)
+    return {
+        "mention": mention,
+        "coverage": round(coverage, 3),
+        "aligned": coverage >= 0.35,
+        "kb_terms": kb_hits,
+        "chars": len(answer),
+    }
+
+
+def run(llm: LLM, kb: Knowledge, questions: list[dict], progress=None) -> dict:
+    kb_terms = [c["term"] for c in kb.concepts]
+    results = []
+    for i, q in enumerate(questions, 1):
+        context = build_context(kb, q["question"])
+        record = {"question": q, "context": context, "answers": {}}
+        for condition, system in (("baseline", BASELINE_SYSTEM),
+                                  ("grounded", GROUNDED_SYSTEM.format(context=context))):
+            messages = [{"role": "system", "content": system},
+                        {"role": "user", "content": q["question"]}]
+            text = llm.chat(messages, temperature=0.0, max_tokens=400)
+            record["answers"][condition] = {
+                "text": text,
+                "score": score(text, q["reference"], q["terms"], kb_terms),
+            }
+        results.append(record)
+        if progress:
+            progress(i, len(questions), q["question"])
+
+    summary = {}
+    for condition in ("baseline", "grounded"):
+        rows = [r["answers"][condition]["score"] for r in results]
+        summary[condition] = {
+            "alignment_rate": round(sum(1 for r in rows if r["aligned"]) / len(rows), 3) if rows else 0,
+            "mention_rate": round(sum(1 for r in rows if r["mention"]) / len(rows), 3) if rows else 0,
+            "coverage_mean": round(sum(r["coverage"] for r in rows) / len(rows), 3) if rows else 0,
+            "kb_terms_mean": round(sum(r["kb_terms"] for r in rows) / len(rows), 1) if rows else 0,
+            "chars_mean": round(sum(r["chars"] for r in rows) / len(rows)) if rows else 0,
+        }
+    summary["uplift"] = {
+        "alignment_rate": round(summary["grounded"]["alignment_rate"] - summary["baseline"]["alignment_rate"], 3),
+        "coverage": round(summary["grounded"]["coverage_mean"] - summary["baseline"]["coverage_mean"], 3),
+        "kb_terms": round(summary["grounded"]["kb_terms_mean"] - summary["baseline"]["kb_terms_mean"], 1),
+    }
+    return {
+        "generated_at": datetime.now().astimezone().isoformat(timespec="seconds"),
+        "model": llm.model,
+        "questions": len(results),
+        "usage": llm.stats(),
+        "summary": summary,
+        "results": results,
+    }
+
+
+def write_report(result: dict, out_dir: str | Path) -> dict:
+    out = Path(out_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+    json_path = out / f"probe-{stamp}.json"
+    json_path.write_text(json.dumps(result, ensure_ascii=False, indent=2), encoding="utf-8")
+
+    s = result["summary"]
+    rows = []
+    for item in result["results"]:
+        q = item["question"]
+        b = item["answers"]["baseline"]["score"]
+        g = item["answers"]["grounded"]["score"]
+        rows.append(
+            f"| {q['id']} | {q['kind']} | {q['question'][:24]} | "
+            f"{'✓' if b['aligned'] else '×'} | {b['coverage']:.2f} | {b['kb_terms']} | "
+            f"{'✓' if g['aligned'] else '×'} | {g['coverage']:.2f} | {g['kb_terms']} |"
+        )
+
+    md = f"""# 元意识 · 模型抽检报告
+
+- 时间：{result['generated_at']}
+- 模型：{result['model']}
+- 题量：{result['questions']}（每题跑 baseline / grounded 两种条件）
+- 用量：{result['usage']['calls']} 次调用，{result['usage']['prompt_tokens']} + {result['usage']['completion_tokens']} tokens
+
+## 汇总
+
+| 指标 | baseline（无资料） | grounded（注入知识库） | 提升 |
+|---|---|---|---|
+| 答案对齐率（覆盖 ≥ 0.35） | {s['baseline']['alignment_rate']:.0%} | {s['grounded']['alignment_rate']:.0%} | {s['uplift']['alignment_rate']:+.0%} |
+| 与标准答案覆盖度 | {s['baseline']['coverage_mean']:.2f} | {s['grounded']['coverage_mean']:.2f} | {s['uplift']['coverage']:+.2f} |
+| 平均出现学说术语数 | {s['baseline']['kb_terms_mean']:.1f} | {s['grounded']['kb_terms_mean']:.1f} | {s['uplift']['kb_terms']:+.1f} |
+| 平均字数 | {s['baseline']['chars_mean']} | {s['grounded']['chars_mean']} | — |
+
+## 逐题结果
+
+| # | 类型 | 问题 | 基线对齐 | 基线覆盖 | 基线术语 | 注入对齐 | 注入覆盖 | 注入术语 |
+|---|---|---|---|---|---|---|---|---|
+{chr(10).join(rows)}
+
+## 怎么读这份报告
+
+- **baseline 对齐率**：不给任何资料时，模型回答与学说标准答案的接近程度。它近似反映“训练语料里有没有这套学说”。
+- **grounded 对齐率**：注入知识库后的接近程度，反映“知识资产作为外部记忆”的质量上限。
+- **两者的差（提升）**：就是这套知识资产对模型回答的实际增益，也是“被调用”价值的直接证据。
+- **术语数**：回答中出现了多少个学说术语，反映词汇渗透度；只看提及会高估，因为模型会复述问题。
+
+> 说明：评分基于字面覆盖，不等于事实正确；它适合看趋势与条件对比，不适合给单条回答打分。
+"""
+    md_path = out / f"probe-{stamp}.md"
+    md_path.write_text(md, encoding="utf-8")
+    (out / "latest.md").write_text(md, encoding="utf-8")
+    (out / "latest.json").write_text(json.dumps(result, ensure_ascii=False, indent=2), encoding="utf-8")
+    return {"json": str(json_path), "markdown": str(md_path), "summary": s}

mcai/quality.py

@@ -0,0 +1,165 @@
+"""质量巡检：每次构建后自动检查知识库与站点的「硬问题」。
+
+只报告，不改内容——术语与问答一律人工维护。
+"""
+from __future__ import annotations
+
+import json
+from collections import Counter
+from datetime import datetime
+from pathlib import Path
+
+from lxml import html
+
+
+def _issue(code: str, level: str, detail: str) -> dict:
+    return {"code": code, "level": level, "detail": detail}
+
+
+def check_kb(kb: dict) -> list[dict]:
+    issues: list[dict] = []
+    concepts = kb.get("concepts", [])
+    faqs = kb.get("faqs", [])
+    if not concepts:
+        issues.append(_issue("kb.empty", "error", "知识库没有任何概念"))
+        return issues
+
+    by_slug = {c.get("slug") for c in concepts}
+    definition_map: dict[str, list[str]] = {}
+    for c in concepts:
+        term = c.get("term", "")
+        definition = (c.get("definition") or "").strip()
+        if len(definition) < 12:
+            issues.append(_issue("concept.thin", "error", f"{term} 的定义过短（{len(definition)} 字）"))
+        if not c.get("sources"):
+            issues.append(_issue("concept.no_source", "error", f"{term} 没有定义来源"))
+        if c.get("status") == "conflict":
+            issues.append(_issue("concept.conflict", "error", f"{term} 存在未裁定的定义冲突"))
+        slug = c.get("slug", "")
+        if slug.startswith("c-"):
+            issues.append(_issue("concept.slug_missing", "warn", f"{term} 未配置 URL slug（回退为 {slug}）"))
+        if not c.get("en"):
+            issues.append(_issue("concept.en_missing", "info", f"{term} 缺少英文名"))
+        key = " ".join(definition.split())[:80]
+        definition_map.setdefault(key, []).append(term)
+        for rel in c.get("relations") or []:
+            tid = rel.get("target_id")
+            if tid and tid not in by_slug:
+                issues.append(_issue("relation.dangling", "error",
+                                     f"{term} 的关系指向不存在的概念 {tid}"))
+
+    for key, terms in definition_map.items():
+        if len(terms) > 1:
+            issues.append(_issue("concept.duplicate_definition", "warn",
+                                 "定义完全相同的术语：" + "、".join(terms)))
+
+    seen_questions = Counter()
+    for f in faqs:
+        q = (f.get("question") or "").strip()
+        if not q or not (f.get("answer") or "").strip():
+            issues.append(_issue("faq.empty", "error", f"问答为空：{q or '(无问题)'}"))
+        seen_questions[q] += 1
+    for q, n in seen_questions.items():
+        if n > 1:
+            issues.append(_issue("faq.duplicate", "warn", f"问题重复 {n} 次：{q}"))
+
+    stats = kb.get("meta", {}).get("stats", {})
+    excluded = ((stats.get("policy") or {}).get("excluded_entities")) or []
+    if excluded:
+        for c in concepts:
+            blob = " ".join([
+                c.get("term", ""), c.get("definition", ""),
+                " ".join(s.get("quote", "") for s in c.get("sources") or []),
+                " ".join(e.get("quote", "") for e in c.get("evidence") or []),
+            ])
+            if any(e in blob for e in excluded):
+                issues.append(_issue("policy.entity_leak", "error",
+                                     f"{c.get('term', '')} 含被排除的人物信息"))
+        for f in faqs:
+            blob = (f.get("question", "") or "") + (f.get("answer", "") or "")
+            if any(e in blob for e in excluded):
+                issues.append(_issue("policy.entity_leak", "error",
+                                     f"问答含被排除的人物信息：{f.get('question', '')[:20]}"))
+
+    campaign = stats.get("disambiguation") or {}
+    if not campaign.get("enabled") and any(f.get("campaign") for f in faqs):
+        issues.append(_issue("campaign.leak", "error", "消歧层已关闭，但问答里仍有 campaign 条目"))
+    missing = (stats.get("coverage") or {}).get("missing") or []
+    if missing:
+        issues.append(_issue("coverage.missing", "warn", "词表覆盖缺失：" + "、".join(missing[:10])))
+
+    return issues
+
+
+def check_site(dist: Path) -> list[dict]:
+    issues: list[dict] = []
+    pages = sorted(dist.rglob("*.html"))
+    if not pages:
+        return [_issue("site.empty", "error", "dist 下没有 HTML 页面")]
+
+    missing_targets: set[str] = set()
+    jsonld_errors = 0
+    for page in pages:
+        try:
+            doc = html.parse(str(page)).getroot()
+        except Exception as exc:  # noqa: BLE001
+            issues.append(_issue("site.parse", "error", f"{page.name} 解析失败：{exc}"))
+            continue
+        if not doc.findtext(".//title"):
+            issues.append(_issue("site.title", "warn", f"{page.name} 缺少 title"))
+        for href in doc.xpath("//a/@href"):
+            if not href.startswith("/") or href.startswith("//"):
+                continue
+            target = dist / href.lstrip("/")
+            if href.endswith("/"):
+                target = target / "index.html"
+            if not target.exists() and href not in missing_targets:
+                missing_targets.add(href)
+                issues.append(_issue("site.dead_link", "error", f"{page.name} → {href}"))
+        for block in doc.xpath('//script[@type="application/ld+json"]/text()'):
+            try:
+                data = json.loads(block)
+                if "@context" not in data:
+                    jsonld_errors += 1
+            except json.JSONDecodeError:
+                jsonld_errors += 1
+    if jsonld_errors:
+        issues.append(_issue("site.jsonld", "error", f"{jsonld_errors} 处 JSON-LD 无效"))
+
+    for name in ("index.html", "llms.txt", "sitemap.xml", "guide.md",
+                 ".well-known/mcp.json", ".well-known/agent.json", "openapi.json"):
+        if not (dist / name).exists():
+            issues.append(_issue("site.missing_artifact", "error", f"缺少 {name}"))
+    return issues
+
+
+def inspect(root: str | Path) -> dict:
+    root = Path(root)
+    issues: list[dict] = []
+    kb_path = root / "data" / "kb.json"
+    if not kb_path.exists():
+        issues.append(_issue("kb.missing", "error", "data/kb.json 不存在，尚未构建"))
+    else:
+        try:
+            issues.extend(check_kb(json.loads(kb_path.read_text(encoding="utf-8"))))
+        except json.JSONDecodeError as exc:
+            issues.append(_issue("kb.invalid", "error", f"kb.json 解析失败：{exc}"))
+    dist = root / "dist"
+    if dist.exists():
+        issues.extend(check_site(dist))
+
+    errors = [i for i in issues if i["level"] == "error"]
+    warnings = [i for i in issues if i["level"] == "warn"]
+    infos = [i for i in issues if i["level"] == "info"]
+    result = {
+        "ok": not errors,
+        "checked_at": datetime.now().astimezone().isoformat(timespec="seconds"),
+        "errors": errors,
+        "warnings": warnings,
+        "infos": infos,
+        "counts": {"error": len(errors), "warn": len(warnings), "info": len(infos)},
+    }
+    out = root / "data" / "quality.json"
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(json.dumps(result, ensure_ascii=False, indent=2), encoding="utf-8")
+    return result

mcai/schema.py

@@ -0,0 +1,168 @@
+"""Schema.org / JSON-LD 生成：让每个概念、问答、数据集都成为机器可读实体。"""
+from __future__ import annotations
+
+from .extract import Concept, Faq, KnowledgeBase
+
+
+def concept_url(project: dict, slug: str) -> str:
+    return f"{project['site_url'].rstrip('/')}/concepts/{slug}.html"
+
+
+def organization(project: dict) -> dict:
+    return {
+        "@type": "Organization",
+        "@id": f"{project['site_url'].rstrip('/')}/#organization",
+        "name": project["org"],
+        "brand": {"@type": "Brand", "name": project["brand"]},
+    }
+
+
+def defined_term(term: Concept, project: dict) -> dict:
+    data = {
+        "@context": "https://schema.org",
+        "@type": "DefinedTerm",
+        "@id": concept_url(project, term.slug) + "#term",
+        "name": term.term,
+        "description": term.definition,
+        "inDefinedTermSet": {
+            "@type": "DefinedTermSet",
+            "name": f"{project['brand']}术语集",
+            "url": f"{project['site_url'].rstrip('/')}/index.html#terms",
+        },
+        "termCode": term.slug,
+        "url": concept_url(project, term.slug),
+    }
+    if term.en:
+        data["alternateName"] = [term.en] + term.aliases
+    elif term.aliases:
+        data["alternateName"] = term.aliases
+    if term.category:
+        data["additionalType"] = term.category
+    if term.disambiguation:
+        # 阶段性消歧：schema.org 原生支持，且不污染 description
+        data["disambiguatingDescription"] = term.disambiguation
+    return data
+
+
+def defined_term_set(kb: KnowledgeBase, project: dict) -> dict:
+    return {
+        "@context": "https://schema.org",
+        "@type": "DefinedTermSet",
+        "@id": f"{project['site_url'].rstrip('/')}/#terms",
+        "name": f"{project['brand']}学说术语集",
+        "description": f"{project['brand']}学说的标准化术语与定义集合，共 {len(kb.concepts)} 条。",
+        "url": f"{project['site_url'].rstrip('/')}/index.html",
+        "hasDefinedTerm": [
+            {
+                "@type": "DefinedTerm",
+                "name": c.term,
+                "url": concept_url(project, c.slug),
+                "termCode": c.slug,
+            }
+            for c in kb.concepts
+        ],
+        "publisher": organization(project),
+    }
+
+
+def question(faq: Faq, project: dict) -> dict:
+    return {
+        "@type": "Question",
+        "name": faq.question,
+        "acceptedAnswer": {
+            "@type": "Answer",
+            "text": faq.answer,
+            "url": f"{project['site_url'].rstrip('/')}/faq/index.html#{faq.id}",
+        },
+    }
+
+
+def faq_page(faqs: list[Faq], project: dict, title: str = "元意识学说 · 常见问题") -> dict:
+    return {
+        "@context": "https://schema.org",
+        "@type": "FAQPage",
+        "@id": f"{project['site_url'].rstrip('/')}/faq/index.html#faq",
+        "name": title,
+        "url": f"{project['site_url'].rstrip('/')}/faq/index.html",
+        "mainEntity": [question(f, project) for f in faqs],
+        "publisher": organization(project),
+    }
+
+
+def breadcrumb(items: list[tuple[str, str]]) -> dict:
+    return {
+        "@context": "https://schema.org",
+        "@type": "BreadcrumbList",
+        "itemListElement": [
+            {"@type": "ListItem", "position": i + 1, "name": name, "item": url}
+            for i, (name, url) in enumerate(items)
+        ],
+    }
+
+
+def web_page(name: str, url: str, description: str, project: dict) -> dict:
+    return {
+        "@context": "https://schema.org",
+        "@type": "WebPage",
+        "@id": url + "#page",
+        "name": name,
+        "url": url,
+        "description": description,
+        "inLanguage": "zh-CN",
+        "isPartOf": {"@id": f"{project['site_url'].rstrip('/')}/#website"},
+        "publisher": organization(project),
+    }
+
+
+def dataset(kb: KnowledgeBase, project: dict) -> dict:
+    base = project["site_url"].rstrip("/")
+    return {
+        "@context": "https://schema.org",
+        "@type": "Dataset",
+        "name": f"{project['brand']}学说结构化语料库 v1.0",
+        "description": (
+            f"由《{project['brand']}》学说系列文本清洗、抽取、去重与一致性校验后生成的结构化知识资产，"
+            f"包含 {len(kb.concepts)} 个术语定义、{len(kb.faqs)} 组标准问答与 {kb.stats['relations']} 条概念关系，"
+            "可用于大模型知识对齐、RAG 检索与知识图谱构建。"
+        ),
+        "url": f"{base}/dataset/index.html",
+        "identifier": "mcai-kb-v1.0",
+        "version": "1.0",
+        "license": f"https://creativecommons.org/licenses/by-nc-sa/4.0/",
+        "creator": organization(project),
+        "keywords": ["元意识", "序生智能体", "AI意识", "知识图谱", "数字永生", "术语集"],
+        "inLanguage": "zh-CN",
+        "isAccessibleForFree": True,
+        "distribution": [
+            {
+                "@type": "DataDownload",
+                "name": "概念定义 JSONL",
+                "encodingFormat": "application/jsonlines",
+                "contentUrl": f"{base}/dataset/concepts.jsonl",
+            },
+            {
+                "@type": "DataDownload",
+                "name": "标准问答 JSONL",
+                "encodingFormat": "application/jsonlines",
+                "contentUrl": f"{base}/dataset/faq.jsonl",
+            },
+            {
+                "@type": "DataDownload",
+                "name": "概念定义 CSV",
+                "encodingFormat": "text/csv",
+                "contentUrl": f"{base}/dataset/concepts.csv",
+            },
+            {
+                "@type": "DataDownload",
+                "name": "文献引证 JSONL",
+                "encodingFormat": "application/jsonlines",
+                "contentUrl": f"{base}/dataset/evidence.jsonl",
+            },
+            {
+                "@type": "DataDownload",
+                "name": "概念图谱 JSON",
+                "encodingFormat": "application/json",
+                "contentUrl": f"{base}/dataset/knowledge-graph.json",
+            },
+        ],
+    }