一、开篇：AI没理解你的内容，可能是因为你的页面彼此不认识

很多人做 GEO 内容时，常见操作是：

今天写一篇“GEO是什么”
明天写一篇“GEO和SEO区别”
后天写一篇“FAQ怎么做”
再过几天写一篇“AI搜索内容优化”

每篇单独看，好像都没问题。

但把它们放进一个网站或内容库里，问题就来了：

页面之间没有关联。
概念之间没有上下文。
FAQ没有指向方法页。
方法页没有链接到案例页。
案例页没有回到核心定义页。

这就像一个项目里有一堆工具类：

utils/
├── string_helper.py
├── date_helper.py
├── user_helper.py
├── order_helper.py
└── misc_helper_final_v2.py

每个文件都说自己有用，但谁依赖谁、谁服务谁、谁是核心入口，没人知道。

AI 读内容库也是类似逻辑。

如果每篇文章都像孤岛，AI 很难判断：

• 哪篇是核心解释页？
• 哪篇是补充说明页？
• 哪些问题属于同一个主题？
• 哪些内容可以互相支撑？
• 哪些页面是“写了但没人引用”的边缘页面？

所以，GEO 不只是单篇内容优化，还要关注内容之间的语义网络。

本文就用 Python 写一个小工具，扫描 Markdown 内容库，自动生成：

页面关系图
主题共现关系
孤岛页面报告
内部链接建议
Mermaid 可视化图

目标很简单：

不只是让单篇文章被 AI 看懂，而是让整个内容库形成可理解的知识网络。

---

二、问题现场：为什么“文章很多”不等于“内容体系完整”？

假设你有这样一个内容库：

content/
├── geo_intro.md
├── seo_vs_geo.md
├── faq_geo.md
├── schema_geo.md
├── content_audit.md
└── ai_answer_monitor.md

看起来很丰富。

但如果页面之间没有关系，它们在机器眼里可能是这样：

每个页面都是一个孤岛。

更理想的状态应该是：

这时候，内容库就不再是一堆文章，而是一个语义网络。

对于 GEO 来说，内容网络至少有三个价值：

价值	说明
帮助机器理解主题层级	哪些页面是核心，哪些页面是补充
帮助用户继续阅读	从定义页跳到方法页，从方法页跳到检测页
帮助内容资产复用	FAQ、案例、工具页之间互相支撑

一句话：

单篇文章解决“这篇内容能不能被理解”。
内容网络解决“整个站点是不是一个完整知识体系”。

---

三、解决方案：做一个GEO内容关系图生成器

我们要写的工具做 5 件事：

1. 读取 Markdown 内容库
2. 提取每篇文章的标题、关键词和内部链接
3. 计算页面之间的主题相似度
4. 找出孤岛页面和弱连接页面
5. 生成 Mermaid 内容关系图和 CSV 报告

整体流程如下：

这个脚本不是替代 SEO 工具，也不是替代大模型分析。

它解决的是一个非常基础但很容易被忽略的问题：

你的内容库，到底有没有形成网络？

---

四、项目结构

新建项目目录：

geo-content-graph/
├── build_graph.py
├── graph_config.json
├── content/
│   ├── geo_intro.md
│   ├── seo_vs_geo.md
│   ├── faq_geo.md
│   ├── schema_geo.md
│   └── monitor_geo.md
└── reports/

说明：

文件或目录	作用
build_graph.py	主程序
graph_config.json	关键词和规则配置
content/	Markdown 内容库
reports/	输出图谱和报告

---

五、准备配置文件

创建 graph_config.json：

{
  "core_terms": [
    "GEO",
    "生成式引擎优化",
    "SEO",
    "AI搜索",
    "FAQ",
    "结构化数据",
    "Schema",
    "内容审计",
    "AI答案",
    "语义网络",
    "知识原子",
    "引用",
    "推荐",
    "检索",
    "理解"
  ],
  "min_similarity": 0.12,
  "max_recommendations_per_page": 3,
  "internal_link_pattern": "\\[([^\\]]+)\\]\\(([^)]+\\.md)\\)"
}

字段说明：

字段	含义
core_terms	要重点识别的主题词
min_similarity	页面相似度推荐阈值
max_recommendations_per_page	每页最多推荐几个内链
internal_link_pattern	Markdown 内链匹配规则

这里的 min_similarity 不建议一开始设太高。

因为中文内容用简单规则做相似度，本来就比较粗糙。

先跑通，再调参。

---

六、准备测试内容

创建 content/geo_intro.md：

# 什么是GEO

GEO是Generative Engine Optimization，中文可以理解为生成式引擎优化。

GEO关注内容是否能被AI搜索系统检索、理解、引用并整合进答案。

如果想继续理解GEO和SEO的区别，可以阅读：[SEO和GEO有什么区别](seo_vs_geo.md)。

GEO内容通常需要FAQ、结构化表达、事实依据和语义网络。

创建 content/seo_vs_geo.md：

# SEO和GEO有什么区别

SEO关注搜索结果页，包括收录、排名、点击和自然流量。

GEO关注AI搜索和生成式问答场景，包括内容是否能被AI理解、引用和推荐。

两者不是替代关系，而是优化场景不同。

相关基础概念可以先看：[什么是GEO](geo_intro.md)。

创建 content/faq_geo.md：

# FAQ对GEO有什么作用

FAQ可以把用户问题和答案组织在一起，让AI更容易识别页面能回答什么问题。

高质量FAQ通常包含明确问题、直接答案、原因解释、示例和边界说明。

FAQ内容也可以和结构化数据结合。

创建 content/schema_geo.md：

# 结构化数据如何辅助GEO

结构化数据可以提升页面的机器可读性。

例如FAQPage Schema可以把问题和答案转换为JSON-LD格式。

结构化数据不能保证AI一定引用内容，但可以让页面信息更清晰。

创建 content/monitor_geo.md：

# 如何监测GEO效果

GEO效果可以通过AI答案快照、目标实体提及率、URL提及率和答案稳定性进行观察。

如果某些核心问题长期没有出现在AI答案中，可能需要补充FAQ、案例或结构化内容。

监测不是优化本身，但可以帮助发现下一步内容缺口。

注意这里有一个刻意设置的问题：

faq_geo.md 没有链接到 schema_geo.md
schema_geo.md 也没有链接回 faq_geo.md
monitor_geo.md 完全没有内链

脚本应该能发现这些弱连接。

---

七、核心代码：生成内容关系图

创建 build_graph.py：

import csv
import json
import math
import re
from pathlib import Path
from collections import Counter, defaultdict
from datetime import datetime


def load_json(file_path):
    path = Path(file_path)
    if not path.exists():
        raise FileNotFoundError(f"配置文件不存在: {file_path}")
    return json.loads(path.read_text(encoding="utf-8"))


def load_markdown_documents(content_dir):
    folder = Path(content_dir)
    if not folder.exists():
        raise FileNotFoundError(f"内容目录不存在: {content_dir}")

    documents = []

    for file_path in sorted(folder.glob("*.md")):
        text = file_path.read_text(encoding="utf-8")
        documents.append({
            "file": file_path.name,
            "path": str(file_path),
            "text": text
        })

    return documents


def clean_markdown(text):
    text = re.sub(r"```.*?```", "", text, flags=re.DOTALL)
    text = re.sub(r"!\[.*?\]\(.*?\)", "", text)
    text = re.sub(r"\[([^\]]+)\]\([^)]+\)", r"\1", text)
    text = re.sub(r"^#{1,6}\s*", "", text, flags=re.MULTILINE)
    text = re.sub(r"[*_>`~-]", "", text)
    return text


def extract_title(markdown_text, fallback):
    match = re.search(r"^#\s+(.+)$", markdown_text, flags=re.MULTILINE)
    if match:
        return match.group(1).strip()
    return fallback.replace(".md", "")


def extract_internal_links(markdown_text, pattern):
    links = re.findall(pattern, markdown_text)
    result = []

    for anchor, target in links:
        result.append({
            "anchor": anchor.strip(),
            "target": target.strip()
        })

    return result


def extract_core_terms(text, core_terms):
    matched = []
    lower_text = text.lower()

    for term in core_terms:
        if term.lower() in lower_text:
            matched.append(term)

    return matched


def tokenize(text):
    """
    轻量分词：
    - 连续中文片段
    - 英文和数字
    - 保留长度大于等于2的token
    """
    text = clean_markdown(text).lower()
    tokens = re.findall(r"[\u4e00-\u9fa5]{2,}|[a-zA-Z0-9]+", text)
    return [token for token in tokens if len(token) >= 2]


def cosine_similarity(counter_a, counter_b):
    common = set(counter_a.keys()) & set(counter_b.keys())

    dot = sum(counter_a[token] * counter_b[token] for token in common)
    norm_a = math.sqrt(sum(value * value for value in counter_a.values()))
    norm_b = math.sqrt(sum(value * value for value in counter_b.values()))

    if norm_a == 0 or norm_b == 0:
        return 0.0

    return dot / (norm_a * norm_b)


def build_document_index(documents, config):
    indexed = []

    for doc in documents:
        text = doc["text"]
        title = extract_title(text, doc["file"])
        links = extract_internal_links(text, config["internal_link_pattern"])
        terms = extract_core_terms(text, config["core_terms"])
        tokens = tokenize(text)

        indexed.append({
            "file": doc["file"],
            "title": title,
            "text": text,
            "links": links,
            "terms": terms,
            "tokens": tokens,
            "vector": Counter(tokens)
        })

    return indexed


def build_existing_edges(indexed_docs):
    """
    根据Markdown内链生成已有关系。
    """
    edges = []

    existing_files = {doc["file"] for doc in indexed_docs}

    for doc in indexed_docs:
        for link in doc["links"]:
            target = link["target"]

            if target in existing_files:
                edges.append({
                    "source": doc["file"],
                    "target": target,
                    "type": "existing",
                    "score": 1.0,
                    "anchor": link["anchor"]
                })

    return edges


def build_similarity_edges(indexed_docs, min_similarity):
    """
    根据文本相似度生成推荐关系。
    """
    edges = []

    for i, doc_a in enumerate(indexed_docs):
        for j, doc_b in enumerate(indexed_docs):
            if i >= j:
                continue

            score = cosine_similarity(doc_a["vector"], doc_b["vector"])

            if score >= min_similarity:
                edges.append({
                    "source": doc_a["file"],
                    "target": doc_b["file"],
                    "type": "recommended",
                    "score": score,
                    "anchor": ""
                })

    return edges


def build_link_stats(indexed_docs, existing_edges):
    files = [doc["file"] for doc in indexed_docs]

    stats = {
        file_name: {
            "out_links": 0,
            "in_links": 0,
            "recommended_links": 0
        }
        for file_name in files
    }

    for edge in existing_edges:
        stats[edge["source"]]["out_links"] += 1
        stats[edge["target"]]["in_links"] += 1

    return stats


def add_recommendation_stats(stats, recommendation_edges):
    for edge in recommendation_edges:
        stats[edge["source"]]["recommended_links"] += 1
        stats[edge["target"]]["recommended_links"] += 1


def find_island_pages(stats):
    islands = []

    for file_name, item in stats.items():
        if item["out_links"] == 0 and item["in_links"] == 0:
            islands.append(file_name)

    return islands


def recommend_missing_links(indexed_docs, existing_edges, similarity_edges, max_per_page):
    """
    从相似页面中找出还没有建立内链的推荐项。
    """
    existing_pairs = set()

    for edge in existing_edges:
        existing_pairs.add((edge["source"], edge["target"]))
        existing_pairs.add((edge["target"], edge["source"]))

    recommendations_by_page = defaultdict(list)

    for edge in sorted(similarity_edges, key=lambda x: x["score"], reverse=True):
        pair = (edge["source"], edge["target"])

        if pair in existing_pairs:
            continue

        if len(recommendations_by_page[edge["source"]]) < max_per_page:
            recommendations_by_page[edge["source"]].append(edge)

        reverse_edge = {
            "source": edge["target"],
            "target": edge["source"],
            "type": edge["type"],
            "score": edge["score"],
            "anchor": edge["anchor"]
        }

        if len(recommendations_by_page[edge["target"]]) < max_per_page:
            recommendations_by_page[edge["target"]].append(reverse_edge)

    return recommendations_by_page


def make_node_id(file_name):
    return re.sub(r"[^a-zA-Z0-9_]", "_", file_name)


def build_mermaid_graph(indexed_docs, existing_edges, recommendation_edges):
    lines = ["flowchart TD"]

    for doc in indexed_docs:
        node_id = make_node_id(doc["file"])
        label = doc["title"].replace('"', "'")
        lines.append(f'    {node_id}["{label}"]')

    lines.append("")

    for edge in existing_edges:
        source = make_node_id(edge["source"])
        target = make_node_id(edge["target"])
        anchor = edge["anchor"].replace('"', "'")
        lines.append(f'    {source} -->|"{anchor}"| {target}')

    lines.append("")

    for edge in recommendation_edges:
        source = make_node_id(edge["source"])
        target = make_node_id(edge["target"])
        score = f"{edge['score']:.2f}"
        lines.append(f'    {source} -.推荐 {score}.-> {target}')

    return "\n".join(lines) + "\n"


def export_page_report(indexed_docs, stats, output_file):
    Path(output_file).parent.mkdir(parents=True, exist_ok=True)

    headers = [
        "file",
        "title",
        "terms",
        "out_links",
        "in_links",
        "recommended_links",
        "is_island"
    ]

    with open(output_file, "w", encoding="utf-8-sig", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=headers)
        writer.writeheader()

        for doc in indexed_docs:
            item = stats[doc["file"]]

            writer.writerow({
                "file": doc["file"],
                "title": doc["title"],
                "terms": " | ".join(doc["terms"]),
                "out_links": item["out_links"],
                "in_links": item["in_links"],
                "recommended_links": item["recommended_links"],
                "is_island": "是" if item["out_links"] == 0 and item["in_links"] == 0 else "否"
            })


def export_recommendations(recommendations_by_page, output_file):
    Path(output_file).parent.mkdir(parents=True, exist_ok=True)

    headers = [
        "source",
        "target",
        "score",
        "suggested_markdown"
    ]

    with open(output_file, "w", encoding="utf-8-sig", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=headers)
        writer.writeheader()

        for source, edges in recommendations_by_page.items():
            for edge in edges:
                target_title = edge["target"].replace(".md", "")
                suggested = f"[{target_title}]({edge['target']})"

                writer.writerow({
                    "source": source,
                    "target": edge["target"],
                    "score": f"{edge['score']:.4f}",
                    "suggested_markdown": suggested
                })


def print_console_summary(indexed_docs, stats, islands, recommendations_by_page):
    print("=" * 90)
    print("GEO内容关系图审计摘要")
    print("=" * 90)
    print(f"页面数量: {len(indexed_docs)}")
    print(f"孤岛页面: {len(islands)}")
    print("-" * 90)

    for doc in indexed_docs:
        item = stats[doc["file"]]
        island_flag = "是" if doc["file"] in islands else "否"

        print(
            f"{doc['file']:<22} "
            f"入链:{item['in_links']:<2} "
            f"出链:{item['out_links']:<2} "
            f"推荐:{item['recommended_links']:<2} "
            f"孤岛:{island_flag:<2} "
            f"主题:{', '.join(doc['terms'])}"
        )

    print("=" * 90)

    if islands:
        print()
        print("发现孤岛页面：")
        for page in islands:
            print(f"- {page}")

    print()
    print("内链推荐预览：")
    for source, edges in recommendations_by_page.items():
        if not edges:
            continue

        print()
        print(f"{source}:")
        for edge in edges:
            print(f"  -> {edge['target']}，相似度 {edge['score']:.4f}")


def main():
    config = load_json("graph_config.json")
    documents = load_markdown_documents("content")

    if not documents:
        print("content目录下没有找到Markdown文件。")
        return

    indexed_docs = build_document_index(documents, config)

    existing_edges = build_existing_edges(indexed_docs)
    similarity_edges = build_similarity_edges(indexed_docs, config["min_similarity"])

    stats = build_link_stats(indexed_docs, existing_edges)
    add_recommendation_stats(stats, similarity_edges)

    islands = find_island_pages(stats)

    recommendations_by_page = recommend_missing_links(
        indexed_docs,
        existing_edges,
        similarity_edges,
        config["max_recommendations_per_page"]
    )

    mermaid_graph = build_mermaid_graph(
        indexed_docs,
        existing_edges,
        similarity_edges
    )

    Path("reports").mkdir(parents=True, exist_ok=True)
    timestamp = datetime.now().strftime("%Y_%m_%d_%H%M%S")

    graph_file = f"reports/content_graph_{timestamp}.mmd"
    page_report_file = f"reports/page_report_{timestamp}.csv"
    recommendation_file = f"reports/link_recommendations_{timestamp}.csv"

    Path(graph_file).write_text(mermaid_graph, encoding="utf-8")
    export_page_report(indexed_docs, stats, page_report_file)
    export_recommendations(recommendations_by_page, recommendation_file)

    print_console_summary(indexed_docs, stats, islands, recommendations_by_page)

    print()
    print(f"Mermaid关系图已生成: {graph_file}")
    print(f"页面报告已生成: {page_report_file}")
    print(f"内链推荐已生成: {recommendation_file}")


if __name__ == "__main__":
    main()

---

八、运行脚本

在项目根目录执行：

python build_graph.py

示例输出：

==========================================================================================
GEO内容关系图审计摘要
==========================================================================================
页面数量: 5
孤岛页面: 2
------------------------------------------------------------------------------------------
faq_geo.md             入链:0  出链:0  推荐:4  孤岛:是  主题:GEO, FAQ, 结构化数据, 理解
geo_intro.md           入链:1  出链:1  推荐:4  孤岛:否  主题:GEO, 生成式引擎优化, AI搜索, FAQ, 结构化数据, 语义网络
monitor_geo.md         入链:0  出链:0  推荐:3  孤岛:是  主题:GEO, AI答案, 提及率
schema_geo.md          入链:0  出链:0  推荐:3  孤岛:是  主题:GEO, 结构化数据, Schema, 引用
seo_vs_geo.md          入链:1  出链:1  推荐:4  孤岛:否  主题:GEO, SEO, AI搜索, 理解, 引用, 推荐
==========================================================================================

发现孤岛页面：
- faq_geo.md
- monitor_geo.md
- schema_geo.md

内链推荐预览：

faq_geo.md:
  -> schema_geo.md，相似度 0.2631
  -> geo_intro.md，相似度 0.2184

schema_geo.md:
  -> faq_geo.md，相似度 0.2631
  -> geo_intro.md，相似度 0.1902

monitor_geo.md:
  -> geo_intro.md，相似度 0.1467
  -> seo_vs_geo.md，相似度 0.1348

这个结果说明什么？

不是这些页面没用，而是它们没有被内容网络连接起来。

尤其是：

faq_geo.md 和 schema_geo.md 主题高度相关，但没有互相链接。
monitor_geo.md 是监测页，但没有连接到核心定义页或方法页。

这就是 GEO 内容体系中的“语义断点”。

---

九、查看生成的 Mermaid 图

脚本会生成：

reports/content_graph_2026_06_14_103000.mmd

内容类似：

flowchart TD
    faq_geo_md["FAQ对GEO有什么作用"]
    geo_intro_md["什么是GEO"]
    monitor_geo_md["如何监测GEO效果"]
    schema_geo_md["结构化数据如何辅助GEO"]
    seo_vs_geo_md["SEO和GEO有什么区别"]

    geo_intro_md -->|"SEO和GEO有什么区别"| seo_vs_geo_md
    seo_vs_geo_md -->|"什么是GEO"| geo_intro_md

    faq_geo_md -.推荐 0.26.-> schema_geo_md
    faq_geo_md -.推荐 0.22.-> geo_intro_md
    schema_geo_md -.推荐 0.26.-> faq_geo_md
    monitor_geo_md -.推荐 0.15.-> geo_intro_md

图里可以看出：

• 实线：已有内链
• 虚线：推荐补充的内链
• 没有实线的页面：需要优先处理

这张图适合放在内容复盘里，比一句“内容结构还要优化”直观得多。

---

十、如何根据报告改内容？

比如报告推荐：

faq_geo.md -> schema_geo.md

可以在 faq_geo.md 中增加一段：

如果需要让FAQ更容易被机器识别，可以继续阅读：[结构化数据如何辅助GEO](schema_geo.md)。

再比如推荐：

monitor_geo.md -> geo_intro.md

可以在 monitor_geo.md 开头补充：

在监测GEO效果之前，建议先理解基础概念：[什么是GEO](geo_intro.md)。

推荐：

schema_geo.md -> faq_geo.md

可以补充：

FAQPage Schema通常需要基于清晰的FAQ内容，具体FAQ写法可以参考：[FAQ对GEO有什么作用](faq_geo.md)。

这样改完后，内容关系会变成：

页面之间开始有了语义路径。

这就是从“文章堆”变成“内容网络”的第一步。

---

十一、踩坑实录：内链不是越多越好

第一次做内容关系优化，很容易把内链做成这样：

每篇文章底部放：
相关阅读：A、B、C、D、E、F、G、H、I、J

看起来很热闹，但实际效果很差。

这就像函数里到处 import：

import everything

跑是能跑，维护起来像拆炸弹。

坑1：无关页面强行互链

错误示例：

GEO FAQ 页面链接到“Python文件读写教程”

除非文章真的讲了用 Python 处理 FAQ，否则这条链接很生硬。

内链应该基于语义关系，而不是基于“我想让你点”。

---

坑2：只从核心页往外链，不让子页面回流

很多内容库是这样的：

核心页 -> 方法页
核心页 -> FAQ页
核心页 -> 案例页

但子页面不链接回核心页。

结果核心页像一个单向广播站。

更好的结构是：

核心页 <-> 方法页
核心页 <-> FAQ页
方法页 <-> 案例页
FAQ页 <-> Schema页

互相支撑，语义更完整。

---

坑3：锚文本太随意

低质量锚文本：

[点击这里](geo_intro.md)
[了解更多](seo_vs_geo.md)
[详情查看](faq_geo.md)

这些锚文本信息量很低。

更好的写法：

[什么是GEO](geo_intro.md)
[SEO和GEO有什么区别](seo_vs_geo.md)
[FAQ对GEO有什么作用](faq_geo.md)

锚文本本身也应该表达语义。

---

坑4：推荐相似度不人工复核

脚本推荐的是“可能相关”，不是“必须链接”。

例如两个页面都出现了“AI搜索”，但实际主题可能不同。

所以推荐内链要人工看一眼。

规则是：

能帮助读者继续理解，就加。
只是关键词相似，但阅读路径不自然，就不加。

---

十二、进阶：给内容库计算一个“网络健康分”

可以在脚本里增加一个简单评分：

def calculate_network_health(indexed_docs, stats, islands):
    total_pages = len(indexed_docs)
    if total_pages == 0:
        return 0

    island_penalty = len(islands) / total_pages

    connected_pages = 0
    for file_name, item in stats.items():
        if item["in_links"] > 0 or item["out_links"] > 0:
            connected_pages += 1

    connected_rate = connected_pages / total_pages

    avg_links = sum(
        item["in_links"] + item["out_links"]
        for item in stats.values()
    ) / total_pages

    health_score = 100
    health_score -= island_penalty * 40
    health_score += min(avg_links, 4) * 5
    health_score += connected_rate * 20

    return max(0, min(100, health_score))

然后在 main() 中加入：

health_score = calculate_network_health(indexed_docs, stats, islands)
print(f"内容网络健康分: {health_score:.2f} / 100")

评分只是辅助参考。

但它可以帮助你判断：

内容库是不是越来越像一个知识网络？
孤岛页面是不是越来越少？
核心页面是不是有足够入链？

---

十三、完整GEO内容网络可以怎么设计？

一个更完整的 GEO 内容网络，不应该只有文章列表，而应该有层级。

可以分成 5 类页面：

页面类型	作用
核心概念页	解释 GEO 是什么
对比解释页	讲清 GEO 和 SEO、AI搜索等区别
方法指南页	给出可执行步骤
工具实战页	提供代码、脚本、检测方法
监测复盘页	观察 AI 答案表现和内容缺口

这样的内容网络更适合 GEO，因为它不是单点表达，而是持续强化同一个主题。

---

十四、避坑指南：GEO内容关系图别踩这5个坑

1. 不要把内容库做成文章仓库

文章仓库是：

写完就放进去。

内容网络是：

每篇文章知道自己属于哪个主题、连接哪个页面、解决哪个问题。

区别很大。

---

2. 不要只关注出链

一个页面自己链接出去很多，不代表它重要。

还要看有没有其他页面链接它。

在内容网络里，入链多的页面通常更像核心节点。

---

3. 不要让核心概念页长期没有更新

如果所有页面都链接到核心概念页，但核心概念页本身很旧，就会形成“旧知识中心”。

建议定期检查核心页：

定义是否过时？
FAQ是否完整？
是否链接到新方法页？
是否包含最新检测工具？

---

4. 不要让工具页脱离概念页

很多技术文章只放代码，不解释它解决什么 GEO 问题。

例如：

我写了一个脚本。

但读者不知道：

这个脚本是在解决召回问题、结构化问题，还是监测问题？

工具页应该链接回对应概念页或方法页。

---

5. 不要把内链优化当成装饰

内链不是为了“页面更丰富”。

内链的本质是表达关系：

这个概念属于哪个主题？
这个方法依赖哪个前提？
这个工具解决哪个问题？
这个FAQ应该指向哪个详细解释？

关系清楚了，内容网络才有意义。

---

十五、下一步行动：给你的GEO内容库画一张关系图

可以按下面流程落地：

建议优先处理三类页面：

页面类型	处理方式
孤岛页面	至少补 1 条指向核心页的链接
高相似无链接页面	增加自然内链
核心概念页	增加到方法页、FAQ页、工具页的链接

一个简单标准：

每篇文章至少有1条出链。
核心页至少有3条入链。
强相关页面之间尽量互相连接。
工具页要链接回它解决的问题。
FAQ页要链接到更详细的解释页。

这不是硬性规则，但很适合作为内容网络的起点。

---

十六、总结：GEO不是文章越多越好，而是关系越清楚越好

最后总结一下。

GEO 内容优化不只是单篇文章的事。

如果一个内容库里：

页面之间没有链接。
主题之间没有层级。
FAQ没有指向方法页。
工具页没有回到概念页。
核心页没有被其他页面引用。

那它就很难形成稳定的语义网络。

本文用 Python 实现了一个 GEO 内容关系图生成器，完成了：

• 扫描 Markdown 内容库
• 提取标题、主题词和内部链接
• 计算页面相似度
• 发现孤岛页面
• 推荐缺失内链
• 生成 CSV 报告
• 生成 Mermaid 内容关系图

SEO 时代，我们常说“页面要被收录”。

GEO 时代，还要补一句：

页面之间要能互相解释。

内容不是堆得越多越好。

真正有价值的是：

核心概念清楚
问题路径清楚
页面关系清楚
知识网络清楚

如果你的内容库像一堆互不认识的 Markdown 文件，那 AI 看不懂也很正常。

毕竟，连页面自己都不知道自己属于哪个体系。