## 一、Graphify 是什么？

Graphify 是一个开源知识图谱工具，专为 AI 编程助手（Claude Code、Cursor、Gemini CLI 等）设计。它能将代码库、文档、论文、图片转化为 可查询的结构化知识图谱。

71x
Token 节省比
22K+
GitHub Stars
25
编程语言支持
48h
从概念到产品
解决上下文膨胀
避免 AI 每次对话都扫描整个代码库，一次性建图后反复查询
解决 AI 失忆
图谱持久化到磁盘，跨会话保留项目理解，换台电脑也能继续
本地运行
代码不离开本机，tree-sitter AST 解析，零数据外泄风险
多模态处理
不仅能解析代码，还能处理 PDF、图片、手写笔记等多种文件类型

灵感来源：Andrej Karpathy 分享的个人知识库工作流，开源社区在 48 小时内将其工程化落地。Rust 重写版由 TtTRz 维护，主打高性能生产环境使用。

Rust 仓库地址： github.com/TtTRz/graphify-rs | Crates.io： crates.io/crates/graphify-rs

## 二、架构与技术栈

### 2.1 Rust Crate 架构

graphify-rs (CLI) ────┬──── graphify-build (构建/去重/社区检测) │ ├── graphify-core (核心数据结构) │ ├── graphify-extract (AST 提取) │ └── graphify-watch (文件监听)

### 2.2 双轨策略（Dual-Track）

确定性轨道
`tree-sitter` AST 解 → 提取类/函数/继承/导入关系 → 精准、零幻觉
概率性轨道
LLM 语义摘要 → 社区检测 → God Node 识别 → 理解"为什么这样设计"
代码文件 ────→ 确定性解析 (AST) ────┐ ├──→ 知识图谱 (节点 + 边 + 社区) 文档/图片 ────→ 概率性解析 (LLM) ────┘

## 三、全功能安装指南

### 3.1 安装 Rust 版（推荐生产使用）

    # 1. 安装 Rust 工具链（如未安装）
    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

    # 2. 安装 graphify-rs
    cargo install graphify-rs

    # 3. 验证安装
    graphify-rs --help

### 3.2 系统要求

依赖 | 说明
--- | ---
运行时 | Rust 编译后二进制（无运行时依赖）
tree-sitter | 静态链接，无需额外安装
平台 | Linux / macOS / Windows

## 四、CLI 命令全览

### 4.1 Rust 版（graphify-rs）

命令 | 功能 | 示例
--- | --- | ---
`init` | 创建配置文件 | `graphify-rs init`
`build` | 构建知识图谱 | `graphify-rs build --path ./src`
`update` | 增量更新已有图谱 | `graphify-rs update`
`watch` | 监听文件变化自动更新 | `graphify-rs watch`
`query` | 交互式查询图谱 | `graphify-rs query`
`path` | 查找两节点间路径 | `graphify-rs path "A" "B"`
`explain` | 解释某个节点 | `graphify-rs explain "AuthService"`
`wiki` | 生成 Wiki 文档 | `graphify-rs wiki`
`svg` | 导出 SVG 可视化 | `graphify-rs svg --output graph.svg`
`graphml` | 导出 GraphML 格式 | `graphify-rs graphml --output g.graphml`
`neo4j` | 导入 Neo4j 数据库 | `graphify-rs neo4j --url bolt://localhost:7687`
`mcp` | 启动 MCP Server | `graphify-rs mcp`
`add` | 手动添加文件 | `graphify-rs add src/new_module.py`

## 五、与 Claude Code 配合最佳实践

### 5.1 配置为 MCP Server（推荐，功能最全）

项目级别配置（`.mcp.json`）：

    {
      "mcpServers": {
        "graphify": {
          "command": "graphify-rs",
          "args": ["mcp", "--graph", "graphify"]
        }
      }
    }

全局配置（`~/.claude/settings.json`）：

    {
      "mcpServers": {
        "graphify": {
          "command": "graphify-rs",
          "args": ["mcp"]
        }
      }
    }

### 5.2 典型工作流

1. `graphify-rs init` — 初始化配置
2. `graphify-rs build` — 首次构建图谱
3. 在 Claude Code 中使用 `/graphify` 查询，或通过 MCP 工具交互
4. `graphify-rs watch` — 后台监听文件变化
5. 提交 `graphify-out/` 到 Git — 持久化图谱，团队共享

### 5.3 Token 节省策略

不使用 Graphify: 每次 Claude Code 会话 ────→ 扫描整个代码库 ────→ ~500K tokens 使用 Graphify: 首次构建（一次性） ────→ ~500K tokens 后续每次会话查询节点 ────→ ~7K tokens ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 节省比: ~71x

### 5.4 与 CLAUDE.md 配合

在项目根目录 `CLAUDE.md` 中添加：

    ## 知识图谱
    本项目使用 Graphify 构建知识图谱，图谱位于 graphify-out/。
    新任务请先通过 graphify MCP 查询相关模块，再开始编码。
    修改代码后运行 graphify-rs update 更新图谱。

## 六、新建项目最佳实践

### 6.1 项目初始化流程

    # 1. 创建项目
    mkdir my-project && cd my-project
    git init

    # 2. 初始化 Graphify
    graphify-rs init

    # 3. 编辑 graphify.toml（按需配置语言和排除项）

    # 4. 首次构建图谱
    graphify-rs build

    # 5. 在 Claude Code 中验证
    claude
    > /graphify .

### 6.2 `graphify.toml` 配置示例

    [project]
    name = "my-project"
    languages = ["typescript", "python", "rust"]

    [exclude]
    dirs = ["node_modules", "dist", ".git", "venv"]
    files = ["*.test.*", "*.spec.*"]

    [build]
    semantic = true               # 启用 LLM 语义分析
    community_detection = true    # 社区检测
    max_files = 5000              # 最大文件数
    max_words = 100000            # 最大词数

### 6.3 Git 集成

    # .gitignore 配置
    # graphify-out/      # 图谱输出（建议提交用于团队共享）
    # .graphify-cache/   # 缓存（可以忽略）

建议：将 `graphify-out/` 提交到仓库，让团队成员克隆后直接获得项目上下文，无需重新构建。

## 七、二次开发最佳实践

### 7.1 接手已有项目的标准流程

1. `git clone <repo> && cd <repo>` — 克隆项目
2. `graphify-rs build` — 立即构建图谱，获得项目全景
3. `graphify-rs query` — 查找 God Node（核心模块）、模块间依赖关系
4. 在 Claude Code 中 `/graphify 查询 "认证模块的入口是什么"`
5. 基于图谱理解，有针对性地开始修改

### 7.2 增量更新策略

    # 方式1: 文件监听模式（开发中持续更新）
    graphify-rs watch &

    # 方式2: 手动增量更新（每次大改后）
    graphify-rs update

    # 方式3: 添加单个新文件
    graphify-rs add src/new_module.py

### 7.3 导出与可视化

    # 导出 SVG 在浏览器中查看
    graphify-rs svg --output graph.svg

    # 导出 GraphML 导入 Neo4j 进行深度分析
    graphify-rs graphml --output graph.graphml

    # 直接导入 Neo4j 数据库
    graphify-rs neo4j --url bolt://localhost:7687

### 7.4 利用图谱理解模块边界

在修改某个模块前，先用 `graphify-rs path` 了解它的上下游依赖，确保修改不会破坏模块边界：

    # 查看 UserController 到 DatabaseService 的调用链
    graphify-rs path "UserController" "DatabaseService"

    # 解释 AuthService 的职责
    graphify-rs explain "AuthService"

## 八、Bug 修正最佳实践

### 8.1 利用图谱定位 BUG

    # 1. 查询 BUG 相关模块
    graphify-rs query "error handling middleware"

    # 2. 查找完整调用链
    graphify-rs path "UserController" "DatabaseService"

    # 3. 解释疑似问题节点
    graphify-rs explain "AuthService"

### 8.2 Claude Code 中的 BUG 修复流程

1. `/graphify` 查询 "最近的错误处理相关变更"
2. 利用 MCP 工具获取模块上下文和依赖关系
3. 理解依赖关系后再修改，避免引入回归
4. `graphify-rs update` 更新图谱
5. 验证修改没有破坏模块边界

### 8.3 已知问题与解决方案

问题 | Issue | 解决方案
--- | --- | ---
大仓库文件数上限 | #162 | 配置 `max_files` / `max_words`
只读模式 Skill 失败 | #195 | 确保 Claude Code 有文件读取权限
`--wiki` 参数缺失 | #177 | 已修复，更新到最新版
`to_wiki()` 未调用 | #354 | 待修复，可手动调用
请求原生 Claude Plugin | #146 | 社区提案中，关注进展

## 九、VSCode 最佳实践

### 9.1 配合 GitHub Copilot Chat

通过 MCP Server 配置，Copilot Chat 可以直接使用 graphify-rs 的图谱查询能力。

### 9.2 推荐 VSCode 扩展组合

扩展 | 用途
--- | ---
GitHub Copilot / Copilot Chat | AI 编程助手
Graphviz Preview | 查看 Graphify 导出的 DOT / SVG 图
Neo4j for VS Code | 如果图谱导入 Neo4j，直接在 IDE 中查询
Markdown Preview | 查看 Graphify 生成的 Wiki 文档

### 9.3 VSCode 工作流

VSCode 编辑代码 │ ↓ Graphify watch 自动检测变更 │ ↓ Copilot Chat 查询图谱上下文 │ ↓ 基于图谱理解 → 精准修改 │ ↓ Graphviz Preview 实时查看图谱变化

### 9.4 VSCode Settings 配置

在项目 `.vscode/settings.json` 中：

    {
      // 避免 Graphify 输出触发 VSCode 文件监听风暴
      "files.watcherExclude": {
        "**/graphify-out/**": true
      },
      // 确保 Copilot Agent 模式启用
      "github.copilot.chat.agent.enabled": true
    }

## 十、Ogham MCP 是什么？

Ogham（发音 "OH-um"）是一个开源的、持久化的、可搜索的 共享记忆 MCP Server，专为 AI 编程代理（Claude Code、Cursor、Codex CLI 等）设计。它基于 Model Context Protocol (MCP)，通过 PostgreSQL + pgvector 实现语义搜索级别的记忆存储与召回。

97.2%
Recall@10 (LongMemEval)
MIT
开源许可证
Go
单二进制，零依赖
跨客户端
Claude / Cursor / Codex

### 10.1 核心能力

持久记忆
记忆存储在 PostgreSQL 中，跨会话、跨客户端、跨项目不丢失。关闭 Claude Code 再打开，记忆依然存在。
混合搜索
向量相似度 + 关键词匹配，通过 Reciprocal Rank Fusion 合并结果。一次 SQL 查询即可完成语义搜索。
Profile 隔离
按项目/工作/个人分区记忆。切换 profile 后，不同上下文的记忆互不干扰。
无需 LLM 存储
存储记忆只需要 embedding 模型，不需要调用 LLM。成本低、速度快、可离线。

### 10.2 为什么需要 Ogham？

Claude Code 存在两个固有问题：

- 上下文压缩（Compaction）：当对话超过上下文窗口时，Claude 会自动压缩对话历史。压缩后，之前的决策、关键细节、架构讨论都会丢失。
- AI 失忆（Amnesia）：每次新会话启动，Claude 对项目的理解从零开始。即使你在昨天的会话中讨论了重要的架构决策，今天也不会记得。

没有 Ogham: 会话1: 讨论架构决策 ────→ 上下文压缩 ────→ 决策丢失 会话2: 重新开始 ────→ 重新扫描代码库 ────→ 重复消耗 Token 有 Ogham: 会话1: 讨论架构决策 ────→ inscribe 保存 ────→ 持久记忆 会话2: recall 召回 ────→ 注入上下文 ────→ 从上次继续

仓库地址： github.com/ogham-mcp/ogham-mcp | 官网： ogham-mcp.dev

## 十一、Ogham MCP 安装与配置

### 11.1 前置条件

依赖 | 说明 | 可选方案
--- | --- | ---
PostgreSQL + pgvector | 持久化存储 + 向量搜索 | 自托管（免费）或 Supabase 云服务
Embedding 提供商 | 生成文本向量 | OpenAI / Ollama 本地 / Cloudflare Workers AI
Ogham CLI | 单二进制 Go 程序 | macOS / Linux / Windows

### 11.2 安装步骤

1. 下载 Ogham CLI
   前往 ogham-mcp.dev/download 下载对应平台的二进制文件，或使用包管理器安装。
2. 准备数据库
   使用 Docker 速启动 PostgreSQL + pgvector：

       docker run -d --name ogham-postgres \\
         -e POSTGRES_PASSWORD=ogham_secret \\
         -p 5432:5432 \\
         pgvector/pgvector:pg16

   或使用 Supabase 免费托管实例。
3. 运行初始化向导

       # 使用 uv 运行（推荐，自动管理依赖）
       uvx --from ogham-mcp ogham init

       # 或直接下载的二进制
       ./ogham init

   初始化向导会引导你完成：
   - 数据库连接字符串配置
   - Embedding 提供商选择
   - Schema 迁移（自动创建表结构）
   - 自动写入 MCP 客户端配置（Claude Code、Cursor 等）
4. 验证安装

       # 测试数据库连接
       uvx --from ogham-mcp ogham doctor

### 11.3 自动配置的 MCP 连接

初始化向导会自动执行 `claude mcp add`，将以下配置写入 `~/.claude/settings.json`：

    {
      "mcpServers": {
        "ogham": {
          "command": "ogham",
          "args": ["serve"],
          "env": {
            "DATABASE_URL": "postgresql://...",
            "EMBEDDING_PROVIDER": "openai"
          }
        }
      }
    }

### 11.4 手动配置（项目级别）

在项目根目录创建 `.mcp.json`：

    {
      "mcpServers": {
        "ogham": {
          "ogham",
          "args": ["serve", "--profile", "my-project"],
          "env": {
            "DATABASE_URL": "postgresql://user:pass@localhost:5432/ogham",
            "EMBEDDING_PROVIDER": "openai",
            "OPENAI_API_KEY": "sk-..."
          }
        }
      }
    }

Profile 建议：每个项目使用独立的 `--profile`，避免不同项目的记忆互相污染。

## 十二、Ogham 核心工具详解

Ogham MCP 暴露给 AI 代理的工具有三个，构成了完整的记忆生命周期：

### 12.1 `inscribe` — 写入记忆

在会话压缩前，Claude 会调用 `inscribe` 将关键上下文保存到数据库。典型保存内容包括：

- 架构决策及原因（为什么选 A 不选 B）
- 项目约定和编码规范
- 已知的技术债务和 TODO
- 用户偏好和工作流习惯
- 模块职责和边界定义

    # Claude 在压缩前自动调用，也可以手动触发
    # 示例：保存一个重要决策
    → inscribe("认证使用 JWT 而非 session，因为 API 需要无状态")

### 12.2 `recall` — 召回记忆

在新会话开始时，Claude 自动调用 `recall` 搜索与当前项目相关的记忆并注入上下文：

- 语义搜索：理解"认证"相关的所有历史讨论
- 关键词匹配：精确查找特定术语
- 混合排序：RRF 融合两种结果，召回率最优

    # 会话开始时自动触发
    → recall("我正在修改认证模块")
    # 返回: "2026-04-20: 认证使用 JWT，原因是 API 需要无状态"
    # 返回: "2026-04-22: 用户偏好使用 HS256 算法"

### 12.3 `search` — 主动搜索

在任何时候都可以主动搜索记忆库：

    # 搜索所有关于数据库的决策
    → search("database decisions")

    # 搜索特定时间段的讨论
    → search("migration plan")

### 12.4 工具对比

工具 | 触发时机 | 目的 | 类比
--- | --- | --- | ---
`inscribe` | 压缩前 / 重要决策后 | 保存上下文 | 写日记
`recall` | 会话开始 / 压缩后 | 自动召回相关记忆 | 回忆
`search` | 任何时候主动查询 | 精确搜索特定内容 | 翻笔记本

## 十三、Ogham Hooks：记忆跨压缩存活

Ogham v0.6.0 引入了 生命周期 Hooks 机制，让 Claude Code 在特定事件（如上下文压缩）发生时自动调用 Ogham 工具，确保记忆不丢失。

### 13.1 安装 Hooks

    uvx ogham-mcp hooks install

这会将 hooks 配置写入 `~/.claude/settings.json`，无需手动编辑。

### 13.2 四个内置 Hooks

Hook | 触发时机 | 执行动作
--- | --- | ---
`pre-compact` | 上下文压缩前 | 调用 `inscribe` 保存当前关键上下文
`post-compact` | 上下文压缩后 | 调用 `recall` 重新注入被压缩掉的记忆
`session-start` | 新会话开始 | 调用 `recall` 加载项目历史记忆
`session-end` | 会话结束 | 调用 `inscribe` 保存本次会话的重要信息

### 13.3 Hooks 工作流

会话开始 ────→ session-start hook ↓ recall 加载历史记忆 ↓ 正常对话 / 编码 ↓ 上下文即将达到上限 ────→ pre-compact hook ↓ inscribe 保存关键信息 ↓ 上下文压缩发生 ↓ post-compact hook ↓ recall 重新注入记忆 ↓ 继续编码（记忆完整） ↓ 会话结束 ────→ session-end hook ↓ inscribe 保存会话摘要
效果：即使对话经历了多次压缩，Claude 依然能"记住"项目关键信息。在 LongMemEval 基准测试（500 道题，ICLR 2025）上达到 97.2% Recall@10。

## 十四、Graphify + Ogham MCP 组合实战

Graphify 解决 项目理解（代码结构、模块关系、架构决策），Ogham MCP 解决 上下文管理（记忆持久化、跨压缩存活、智能召回）。两者组合实现 1 + 1 > 2 的效果：

Graphify Ogham MCP ┌───────────────┐ ┌───────────────┐ │ AST 解析代码 │ │ 会话记忆存储 │ │ 知识图谱构建 │ │ 语义搜索召回 │ │ 模块依赖分析 │ │ 跨压缩不丢失 │ │ 社区检测 │ │ Profile 隔离 │ └───────┬───────┘ └───────┬───────┘ │ │ │ Graphify 图谱输出 │ Ogham 记忆输出 └──────────┬────────────┘ ↓ Claude Code 完整上下文 ↓ 精准编码 · 零重复 · 不遗忘

### 14.1 组合安装（一次性）

    # 1. 安装 Graphify
    cargo install graphify-rs

    # 2. 安装 Ogham + 初始化
    uvx --from ogham-mcp ogham init

    # 3. 安装 Ogham Hooks
    uvx ogham-mcp hooks install

    # 4. 验证两个 MCP Server 都已注册
    cat ~/.claude/settings.json | grep -E "graphify|ogham"

### 14.2 组合工作流

阶段 | Graphify 做什么 | Ogham 做什么
--- | --- | ---
首次接手项目 | `build` 构建图谱，理解结构 | `recall` 加载项目历史决策
开发新功能 | `path` 查找模块依赖链 | `recall` 搜索相关历史讨论
架构决策 | `explain` 理解现有模块职责 | `inscribe` 保存新决策及原因
修复 BUG | `query` 定位问题模块 | `search` 搜索已知类似问题
上下文压缩后 | 图谱不变，随时可查 | `recall` 自动恢复记忆
跨天继续工作 | 图谱持久化，无需重建 | `recall` 自动加载昨天讨论

### 14.3 完整 `~/.claude/settings.json`（双工具配置）

    {
      "mcpServers": {
        "graphify": {
          "command": "graphify-rs",
          "args": ["mcp"]
        },
        "ogham": {
          "command": "ogham",
          "args": ["serve"],
          "env": {
            "DATABASE_URL": "postgresql://user:pass@localhost:5432/ogham",
            "EMBEDDING_PROVIDER": "openai"
          }
        }
      }
    }

### 14.4 组合 CLAUDE.md 模板

    ## 项目工具
    ### Graphify 知识图谱
    - 图谱位置: graphify-out/
    - 新任务先通过 graphify MCP 查询相关模块
    - 修改代码后运行 graphify-rs update

    ### Ogham 持久记忆
    - Profile: my-project
    - 重要决策后主动 inscribe 保存
    - 遇到类似问题先 search 历史记忆
    - Hooks 已安装，压缩前后自动记忆

### 14.5 实际使用场景示例

#### 场景 A：接手一个 2 年历史的遗留项目

    # 第 1 步：Graphify 构建图谱
    graphify-rs build

    # 第 2 步：通过图谱识别核心模块
    graphify-rs query

    # 第 3 步：Ogham 自动召回历史记忆
    # （如果有前人留下的 inscribe 记录）

    # 第 4 步：针对性查询 + 开始修改
    graphify-rs path "PaymentService" "OrderController"

    # 第 5 步：理解后 inscribe 保存自己的发现
    # （Claude 自动调用，无需手动）

#### 场景 B：长会话中的架构重构

    # 上午：讨论方案，Claude 记住决策
    # 上下文压缩 → Ogham pre-compact hook 保存决策
    # 下午：开始实施，post-compact hook 恢复记忆
    # 遇到分岐 → search 搜索上午讨论的结论
    # Graphify path 确认重构影响范围
    # 晚上：会话结束 → session-end hook 保存全天总结
    # 第二天：session-start hook 自动加载昨天总结

组合效果：Graphify 让 Claude "看懂代码"，Ogham 让 Claude "记住讨论"。两者结合，Claude Code 从"每次从零开始"变为"带着项目全部上下文工作"。
参考阅读： Solving Context Bloat and AI Amnesia with Graphify and Ogham MCP | Give your AI agent a memory that survives compaction

## 十五、完整配置清单

### 15.1 全局配置（`~/.claude/settings.json`）

    {
      "mcpServers": {
        "graphify": {
          "command": "graphify-rs",
          "args": ["mcp"]
        },
        "ogham": {
          "command": "ogham",
          "args": ["serve"],
          "env": {
            "DATABASE_URL": "postgresql://user:pass@localhost:5432/ogham",
            "EMBEDDING_PROVIDER": "openai"
          }
        }
      }
    }

### 15.2 项目配置（`graphify.toml`）

    [project]
    name = "my-project"
    languages = ["typescript", "python"]

    [exclude]
    dirs = ["node_modules", "dist", ".git", "venv", "graphify-out"]
    files = ["*.test.*", "*.spec.*", "*.min.js"]

    [build]
    semantic = true
    community_detection = true
    god_node_detection = true
    max_files = 5000
    max_words = 100000

### 15.3 项目 CLAUDE.md 提示

    ## Graphify 知识图谱
    - 图谱位置: graphify-out/
    - 查询方式: 通过 graphify MCP 工具
    - 新任务先查询相关模块，再开始编码
    - 修改后运行 graphify-rs update 更新图谱

    ## Ogham 持久记忆
    - Profile: my-project
    - 重要决策后自动 inscribe，压缩后自动 recall
    - Hooks 已安装，无需手动管理记忆

### 15.4 VSCode 配置（`.vscode/settings.json`）

    {
      "files.watcherExclude": {
        "**/graphify-out/**": true
      },
      "github.copilot.chat.agent.enabled": true
    }

### 15.5 Git 忽略（`.gitignore`）

    # Graphify 缓存（可忽略）
    .graphify-cache/

    # Graphify 输出（建议提交用于团队共享，按需调整）
    # graphify-out/

## 十六、总结：何时该用？

### 16.1 Graphify 适用场景

场景 | 推荐程度 | 理由
--- | --- | ---
大项目（>100 文件） | 强烈推荐 | 节省 70x Token，快速理解结构
多语言混合项目 | 强烈推荐 | 25 种语言统一分析
二开 / 接手他人代码 | 强烈推荐 | God Node 识别、社区检测、路径询
长期维护的项目 | 推荐 | 图谱持久化，跨会话复用理解
中等项目（20-100 文件） | 可选 | 有一定收益，但不如大项目显著
小项目（<20 文件） | 不推荐 | Token 节省收益不明显
纯脚本 / 单文件 | 不需要 | 知识图谱无意义

### 16.2 Ogham MCP 适用场景

场景 | 推荐程度 | 理由
--- | --- | ---
长会话（经常触发压缩） | 强烈推荐 | 记忆跨压缩不丢失
跨天/跨周继续工作 | 强烈推荐 | 自动召回历史讨论
多人协作同一项目 | 强烈推荐 | 共享记忆池，知识沉淀
架构决策频繁的项目 | 推荐 | 记录决策原因，避免重复讨论
一次性小任务 | 不需要 | 无需持久记忆

### 16.3 组合使用推荐

两者都用
大项目 + 长期维护 + 多人协作 → Graphify 理解代码 + Ogham 记住讨论
只用 Graphify
接手项目快速理解结构 → 代码图谱足够，无需持久记忆
只用 Ogham
长期项目 + 频繁压缩 → 记忆不丢失比图谱更重要

> 一句话总结：Graphify 让 Claude Code "看懂代码"，Ogham 让 Claude Code "记住讨论"。两者结合，Claude 从"每次都从零开始"变为"带着项目全部上下文工作"——这才是 AI 编程助手的完全体形态。