装上就回不去了：CodeGraph 让 AI 编程效率飙升 92%，它到底做了什么？一、你是不是也经历过这种绝望？你问

一个 5.2K+ Star 的 MIT 开源工具，把代码库变成 AI 能直接"查字典"的知识图谱。
从此告别 grep → read → grep → read 的死循环。

一、你是不是也经历过这种绝望？

你问 Claude Code："这个项目的用户认证逻辑在哪？"

然后你看着它开始疯狂输出：

grep "auth"        → 47 个匹配文件，好的，下一个
read auth.ts       → 300 行，没有，下一个
grep "login"       → 23 个匹配，再来
read login.ts      → 250 行，不对，再来
glob "**/auth/**"  → 15 个文件，饶了我吧
read ...           → 循环往复，无穷尽也

52 次工具调用、1 分 37 秒后，它终于告诉你答案。而你的 Token 额度已经燃烧了一半。

这就好比你去图书馆找一本书：

flowchart LR
    subgraph 传统方式["❌ 传统方式 = 瞎子摸象"]
        A1["🔍 挨个书架翻"] -->|"grep"| B1["📖 抽出来翻目录"]
        B1 -->|"read"| C1["😩 不对，放回去"]
        C1 -->|"grep again"| A1
    end

    subgraph CodeGraph["✅ CodeGraph = 图书馆索引卡片"]
        A2["🎯 查卡片目录"] -->|"codegraph_search"| B2["📇 瞬间定位书架号"]
        B2 -->|"即时返回"| C2["✅ 拿到书，还附带相关书单"]
    end

    style 传统方式 fill:#ffeaa7,stroke:#fdcb6e
    style CodeGraph fill:#55efc4,stroke:#00b894

CodeGraph 做的就是这件事 — 它提前给整个代码库建好了"索引卡片"，AI 不用翻书架，直接查卡片就能找到一切。

二、CodeGraph 到底是什么？

一句话：它是一个把代码库变成"可查询的图数据库"的工具。

更通俗地说，它干了三件事：

graph TD
    subgraph 第一步["⚙️ 第一步：解析"]
        S1["用 tree-sitter 把代码<br/>解析成 AST 抽象语法树"]
        S1_DESC["就像把一本书的每个段落、<br/>每个句子都标注好结构"]
    end

    subgraph 第二步["🗄️ 第二步：存储"]
        S2["存入 SQLite 数据库<br/>+ FTS5 全文索引"]
        S2_DESC["就像图书馆的索引卡片柜，<br/>每个函数/类/变量都有一张卡片"]
    end

    subgraph 第三步["🔄 第三步：关联"]
        S3["建立符号 ↔ 调用 ↔ 继承 的关系图"]
        S3_DESC["每张卡片之间拉上绳子：<br/>A 调用了 B，C 继承了 D"]
    end

    第一步 -->|"结构化数据"| 第二步
    第二步 -->|"索引卡片"| 第三步
    第三步 -->|"知识图谱"| RESULT["🧠 代码知识图谱<br/>AI 可以直接查询"]

    style 第一步 fill:#74b9ff,stroke:#0984e3,color:#fff
    style 第二步 fill:#a29bfe,stroke:#6c5ce7,color:#fff
    style 第三步 fill:#fd79a8,stroke:#e84393,color:#fff
    style RESULT fill:#00b894,stroke:#00a381,color:#fff

核心类比：图书馆的三种用法

方式	类比	效率
没有 CodeGraph	每次去图书馆都从头翻书架	😫 52 次操作 / 1分37秒
用 CodeGraph 轻量工具	直接查索引卡片柜	🚀 3 次操作 / 17秒
用 CodeGraph Explore Agent	雇了个图书管理员帮你查	🤖 1 次操作 / 19秒

四个关键特点

graph LR
    A["🔮 预索引<br/>一次构建，永久查询"] 
    B["🏠 100% 本地<br/>零网络依赖，数据不离机"]
    C["🔄 自动同步<br/>文件变了，2秒内自动更新索引"]
    D["🧩 框架感知<br/>识别 13 种框架的路由"]
    
    A --> E["CodeGraph"]
    B --> E
    C --> E
    D --> E
    
    style A fill:#6c5ce7,color:#fff
    style B fill:#00b894,color:#fff
    style C fill:#0984e3,color:#fff
    style D fill:#e17055,color:#fff
    style E fill:#2d3436,color:#fff,stroke:#636e72,stroke-width:3px

"预索引" 这个概念很重要——你只需要在项目里跑一次 codegraph init -i，之后每次 AI 干活都可以直接查，不用重复扫描。就像你不需要每次去图书馆都重新整理一遍书架。

三、它到底解决了什么问题？

问题一：AI Agent 探索代码像"没头苍蝇"

传统 AI 编程助手的探索流程是这样的：

sequenceDiagram
    participant You as 🙋 你
    participant AI as 🤖 AI Agent
    participant FS as 📂 文件系统

    You->>AI: "这个项目的认证逻辑在哪？"

    rect rgb(255, 234, 167)
        Note over AI,FS: ❌ 没有 CodeGraph 的情况
        AI->>FS: grep "auth"
        FS-->>AI: 47 个匹配文件...
        AI->>FS: read auth/service.ts
        FS-->>AI: 300 行代码
        AI->>FS: grep "login"
        FS-->>AI: 23 个匹配
        AI->>FS: read login/handler.ts
        FS-->>AI: 250 行代码
        AI->>FS: glob "**/auth/**"
        FS-->>AI: 15 个文件
        AI->>FS: read auth/middleware.ts
        FS-->>AI: 200 行代码
        Note over AI,FS: 😫 52 次调用 · 89K tokens · 1分37秒
    end

    AI-->>You: "找到了，认证逻辑在..."

    rect rgb(85, 239, 196)
        Note over AI,FS: ✅ 有 CodeGraph 的情况
        AI->>FS: codegraph_search "auth"
        FS-->>AI: AuthService + 调用链 + 完整关系图
        Note over AI,FS: 🚀 3 次调用 · 57K tokens · 17秒
    end

    AI-->>You: "找到了，认证逻辑在..."

同样的答案，完全不同的代价。

Benchmark 数据：六大代码库实测

以下是作者在 6 个真实项目上的 benchmark 对比：

gantt
    title 六大代码库探索耗时对比（秒）
    dateFormat X
    axisFormat %s
    
    section VS Code (TS)
    有 CodeGraph (17s)    :0, 17
    无 CodeGraph (97s)    :0, 97
    
    section Excalidraw (TS)
    有 CodeGraph (29s)    :0, 29
    无 CodeGraph (105s)   :0, 105
    
    section Claude Code (Py+Rust)
    有 CodeGraph (39s)    :0, 39
    无 CodeGraph (68s)    :0, 68
    
    section Claude Code (Java)
    有 CodeGraph (19s)    :0, 19
    无 CodeGraph (82s)    :0, 82
    
    section Alamofire (Swift)
    有 CodeGraph (22s)    :0, 22
    无 CodeGraph (99s)    :0, 99
    
    section Swift 编译器 (C++)
    有 CodeGraph (35s)    :0, 35
    无 CodeGraph (128s)   :0, 128

指标	无 CodeGraph	有 CodeGraph	提升
平均工具调用次数	39 次	3.2 次	↓ 92%
平均探索耗时	97 秒	27 秒	↑ 71%
Token 消耗	88K	59K	↓ 30%
文件读取次数	~18 次	0 次	归零

最夸张的是 Java 项目（Claude Code）：仅 1 次工具调用就完成了探索。而 Swift 编译器这种 25,874 个文件、272,898 个节点的巨型项目，索引只花了不到 4 分钟。

问题二：改代码像"蒙着眼做手术"

你要改一个 calculate_tax 函数，但你不知道：

哪些地方调用了它？
改了之后哪个测试会挂？
有没有前端页面也依赖这个逻辑？

graph TD
    F["🔴 calculate_tax<br/>你要改的函数"] -->|"被调用"| A["OrderService.checkout<br/>订单结算"]
    F -->|"被调用"| B["InvoiceService.generate<br/>发票生成"]
    F -->|"被调用"| C["ReportService.monthly<br/>月报统计"]
    F -->|"被调用"| D["ApiController.export<br/>API 导出"]
    
    A -->|"测试覆盖"| T1["✅ order.test.ts"]
    B -->|"测试覆盖"| T2["✅ invoice.test.ts"]
    C -->|"测试覆盖"| T3["✅ report.test.ts"]
    D -->|"没有测试!"| T4["⚠️ 无测试覆盖"]
    
    F -->|"前端也依赖"| FE["🧩 TaxDisplay.vue<br/>前端展示组件"]

    style F fill:#ff6b6b,stroke:#d63031,color:#fff,stroke-width:3px
    style T4 fill:#ffeaa7,stroke:#fdcb6e
    style FE fill:#a29bfe,stroke:#6c5ce7,color:#fff

    linkStyle 0,1,2,3 stroke:#ff0000,stroke-width:2px

没有 CodeGraph：你需要手动 grep 所有调用、人眼追踪引用链、猜测影响范围——大概率会漏。

有了 CodeGraph：一行 codegraph_impact calculate_tax，5 秒内拿到完整的影响半径分析图，连哪个测试会挂都告诉你。

问题三：Token 全烧在了"找代码"而不是"写代码"

pie title 无 CodeGraph 时 Token 消耗分布
    "发现代码位置 (grep/glob)" : 45
    "读取文件内容 (read)" : 30
    "理解代码逻辑" : 15
    "真正写代码" : 10

有了 CodeGraph，"发现位置" 和 "读取文件" 的 Token 几乎归零，省下的 30% Token 全用在真正有用的理解和编写上。

四、它肚子里装了什么？（技术原理简析）

不想看原理的朋友可以跳过这一节，但我尽量用大白话讲清楚。

技术栈一览

graph TD
    subgraph 输入["📥 输入层"]
        CODE["你的代码库<br/>19+ 种语言"]
    end

    subgraph 解析["🔬 解析层"]
        TS["tree-sitter<br/>解析 AST"]
        FW["框架路由识别<br/>Django/Express/Spring..."]
    end

    subgraph 存储["🗄️ 存储层"]
        DB["SQLite 数据库<br/>.codegraph/codegraph.db"]
        FTS["FTS5 全文索引<br/>比 grep 快 N 倍"]
    end

    subgraph 同步["🔄 同步层"]
        WATCH["原生文件监听<br/>FSEvents / inotify"]
        DEBOUNCE["2 秒防抖<br/>自动增量索引"]
    end

    subgraph 输出["📤 输出层"]
        MCP["MCP Server<br/>8 个工具"]
        CLI["CLI 命令行<br/>11 个子命令"]
        API["JS/TS 编程接口"]
    end

    输入 --> 解析 --> 存储 --> 同步
    存储 --> 输出

    style 输入 fill:#dfe6e9,stroke:#b2bec3
    style 解析 fill:#74b9ff,stroke:#0984e3,color:#fff
    style 存储 fill:#a29bfe,stroke:#6c5ce7,color:#fff
    style 同步 fill:#00b894,stroke:#00a381,color:#fff
    style 输出 fill:#fd79a8,stroke:#e84393,color:#fff

三个核心组件

1. tree-sitter —— 代码的"语法老师"

tree-sitter 是一个增量解析库，能把你写的代码拆成一棵抽象语法树（AST）。比如：

function add(a: number, b: number): number {
  return a + b;
}

被 tree-sitter 解析后，CodeGraph 就知道了："这是一个叫 add 的函数，接收两个 number 参数，返回 number，定义在第 1 行到第 3 行。"

2. SQLite + FTS5 —— 代码的"搜索引擎"

解析出来的所有符号（函数、类、变量、接口...）和关系（调用、继承、导入...）都存进 SQLite。FTS5 是 SQLite 内置的全文搜索引擎，查起来比 grep 快一个数量级。

整张图就一个 .codegraph/codegraph.db 文件，你可以复制、备份、甚至 .gitignore 掉——完全便携。

3. 文件监听 + 防抖 —— 代码的"自动同步器"

你在 IDE 里敲代码，CodeGraph 用操作系统的原生文件监听（macOS 的 FSEvents、Linux 的 inotify、Windows 的 ReadDirectoryChangesW）感知到变化，等 2 秒防抖窗口（防止高频写入），然后自动增量更新索引。

一句话：写完代码，2 秒后索引就更新好了，零感知。

框架路由识别：不止于语言解析

CodeGraph 能干的不止是"函数 A 调用了函数 B"。它还能理解 Web 框架的路由：

graph TD
    CG["🔮 CodeGraph<br/>路由解析引擎"] 
    
    CG --> DJ["Django<br/>urls.py → path()/re_path()"]
    CG --> FL["Flask<br/>@app.route('/api/...')"]
    CG --> FA["FastAPI<br/>@app.get()/@router.post()"]
    CG --> EX["Express<br/>app.get()/router.post()"]
    CG --> LV["Laravel<br/>Route::get()/@Controller"]
    CG --> RL["Rails<br/>get '/x', to: 'ctrl#action'"]
    CG --> SP["Spring<br/>@GetMapping/@RequestMapping"]
    CG --> GO["Go 系<br/>Gin/chi/gorilla/mux"]
    CG --> RS["Rust 系<br/>Axum/actix/Rocket"]
    CG --> NET["ASP.NET<br/>[HttpGet('/x')]"]
    CG --> VP["Vapor<br/>app.get('x', use:)"]
    CG --> RR["React Router"]
    CG --> SK["SvelteKit"]
    
    DJ --- DJ_EX["path('user/&lt;id&gt;', views.profile)<br/>→ profile 函数处理 GET /user/123"]
    EX --- EX_EX["app.get('/api/login', handler)<br/>→ handler 函数处理 POST /api/login"]

    style CG fill:#6c5ce7,color:#fff,stroke:#5a4bd1,stroke-width:3px

这有什么用？比如你问 AI："POST /api/login 这个接口是谁处理的？"——CodeGraph 能直接从路由反查到处理函数，不用人肉翻代码。

五、八把瑞士军刀：MCP 工具详解

CodeGraph 通过 MCP (Model Context Protocol) 暴露了 8 个工具。我按使用场景把它们分成三组：

graph TD
    subgraph 发现组["🔍 发现组：这个符号在哪？"]
        T1["codegraph_search<br/>按名称查找符号<br/>例: search 'UserService'"]
        T6["codegraph_node<br/>获取符号详情+源码<br/>例: node 'AuthController'"]
        T7["codegraph_files<br/>索引化的文件结构<br/>比 ls 更智能"]
    end

    subgraph 关系组["🔗 关系组：这跟谁有关？"]
        T3["codegraph_callers<br/>谁调用了 X<br/>例: callers 'getUserById'"]
        T4["codegraph_callees<br/>X 调用了谁<br/>例: callees 'main'"]
        T5["codegraph_impact<br/>修改影响半径<br/>例: impact 'calculate_tax'"]
    end

    subgraph 上下文组["📋 上下文组：给我完整背景"]
        T2["codegraph_context<br/>为任务构建代码上下文<br/>⚠️ 主会话禁用！"]
        T8["codegraph_status<br/>索引健康度/统计<br/>节点数、后端类型等"]
    end

    style 发现组 fill:#74b9ff,stroke:#0984e3,color:#fff
    style 关系组 fill:#00b894,stroke:#00a381,color:#fff
    style 上下文组 fill:#e17055,stroke:#d63031,color:#fff

核心使用流程

flowchart LR
    A["🤔 想改一个函数"] --> B["codegraph_search<br/>找到符号"]
    B --> C["codegraph_callers<br/>看谁在用"]
    C --> D["codegraph_impact<br/>改了会影响啥"]
    D --> E["codegraph_node<br/>看具体实现"]
    E --> F["🔨 放心改代码"]
    
    A -.->|"不确定在哪"| G["codegraph_context<br/>spawn Explore Agent"]
    G -.-> B

    style A fill:#dfe6e9,stroke:#b2bec3
    style F fill:#00b894,stroke:#00a381,color:#fff

⚠️ 最重要的使用规则

主会话中永远不要直接调用 codegraph_context！ 它会返回大量源码，会把你的上下文窗口撑爆。

正确姿势是：spawn 一个 Explore Agent，让它去干重活，然后把结果摘要带回主会话。就像你让实习生去翻资料，然后给你写一份简报。

你直接干	让 Explore Agent 干
`codegraph_search` — 找符号	`codegraph_context` — 构建上下文
`codegraph_callers` — 查调用者	`codegraph_explore` — 大范围探索
`codegraph_impact` — 影响分析
`codegraph_node` — 看详情

六、实战效果：数据不会说谎

六大代码库全面对比

%%{init: {'theme': 'base', 'themeVariables': { 'primaryColor': '#6c5ce7'}}}%%
graph TD
    subgraph VSC["VS Code (TypeScript)"]
        VSC_B["4002 文件 · 59377 节点"]
        VSC_W["无 CG: 52 次调用 · 89K tokens · 1分37秒 · ~15次文件读取"]
        VSC_C["有 CG: 3 次调用 · 57K tokens · 17秒 · 0次文件读取"]
        VSC_W -->|"↓94% 调用 ↓82% 耗时"| VSC_C
    end

    subgraph EXC["Excalidraw (TypeScript)"]
        EXC_B["626 文件 · 9859 节点"]
        EXC_W["无 CG: 47 次调用 · 78K tokens · 1分45秒 · ~20次文件读取"]
        EXC_C["有 CG: 3 次调用 · 57K tokens · 29秒 · 0次文件读取"]
        EXC_W -->|"↓94% 调用 ↓72% 耗时"| EXC_C
    end

    subgraph SWC["Swift 编译器 (Swift/C++)"]
        SWC_B["25874 文件 · 272898 节点"]
        SWC_W["无 CG: 37 次调用 · 99K tokens · 2分8秒 · ~20次文件读取"]
        SWC_C["有 CG: 6 次调用 · 77K tokens · 35秒 · 0次文件读取"]
        SWC_W -->|"↓84% 调用 ↓73% 耗时"| SWC_C
    end

    style VSC_W fill:#ffeaa7,stroke:#fdcb6e
    style VSC_C fill:#00b894,stroke:#00a381,color:#fff
    style EXC_W fill:#ffeaa7,stroke:#fdcb6e
    style EXC_C fill:#00b894,stroke:#00a381,color:#fff
    style SWC_W fill:#ffeaa7,stroke:#fdcb6e
    style SWC_C fill:#00b894,stroke:#00a381,color:#fff

三个惊人发现

文件读取归零 — 有 CodeGraph 后，AI Agent 再也不用直接读文件了。所有信息都从图里查。这意味着你不再需要给 AI 开文件系统的权限。
跨语言无感知 — Claude Code 那个 Python + Rust 混合项目，CodeGraph 一条龙追踪：Python 函数 → Rust 绑定 → C FFI，无缝衔接。
百万节点不是事 — Swift 编译器 27 万个节点，索引不到 4 分钟，查询响应毫秒级。

Alamofire 调用链追踪示例

这是 benchmark 中最精彩的一个案例——追踪 Alamofire 从高层 API 到底层系统调用的完整链路：

graph LR
    A["Session.request()"] -->|"第1层"| B["Request.makeURLRequest()"]
    B -->|"第2层"| C["Session.requestQueue.async"]
    C -->|"第3层"| D["URLSession.dataTask()"]
    
    A -.->|"impact depth=3"| D

    style A fill:#6c5ce7,color:#fff
    style D fill:#e17055,color:#fff

一次 codegraph_impact 调用，depth=3，9 步调用链，瞬间呈现。 没有 CodeGraph 你至少需要 grep 10 次、read 5 个文件才能拼出这个图。

七、三分钟上手

安装（真正的零门槛）

# 1. 一条命令启动交互式安装器
npx @colbymchenry/codegraph

它会自动检测你装了 Claude Code、Cursor 还是 Codex，问你要配哪个，然后帮你写好所有配置。

flowchart TD
    START(["🚀 npx @colbymchenry/codegraph"]) --> DETECT["🔍 自动检测你的 IDE/Agent"]
    DETECT --> CHOOSE{"🎯 要配给谁？"}
    CHOOSE -->|"Claude Code"| CC["写入 ~/.claude.json"]
    CHOOSE -->|"Cursor"| CS["写入 .cursor/rules/"]
    CHOOSE -->|"Codex"| CX["写入 ~/.codex/AGENTS.md"]
    CHOOSE -->|"全都要"| ALL["全部写入"]
    
    CC --> INIT
    CS --> INIT
    CX --> INIT
    ALL --> INIT
    
    INIT["📦 codegraph init -i<br/>初始化 + 构建索引"] --> DONE(["✅ 搞定！"])
    
    style START fill:#6c5ce7,color:#fff
    style DONE fill:#00b894,color:#fff

日常使用

# 开发中保持索引同步（自动监听，一般不需要手动跑）
codegraph sync

# 查看索引状态
codegraph status
# 输出: 59377 nodes · 128000 edges · Backend: native ✅

# 搜索符号
codegraph query "UserService"

# 修改前的影响分析
codegraph affected src/services/tax.ts
# 输出: 改了 tax.ts 需要重跑这 3 个测试文件...

CI/CD 集成（增量跑测试，告别全量重跑）

# 只跑受本次改动影响的测试
git diff --name-only HEAD | codegraph affected --stdin | xargs npx vitest run

这就叫精准打击——改了 3 个文件，只跑 5 个相关测试，而不是全量跑 2000 个。

八、避坑指南 & 最佳实践

✅ Do（推荐做法）

graph TD
    subgraph DO["✅ DO"]
        D1["主会话用轻量工具:<br/>search / callers / impact / node"]
        D2["重量探索 spawn Explore Agent"]
        D3["配置 exclude 排除<br/>node_modules / dist / build"]
        D4["确认 Backend: native<br/>别用 WASM 回退"]
        D5["CI 中用 affected<br/>增量跑测试"]
    end

    style DO fill:#55efc4,stroke:#00b894

❌ Don't（千万别干）

graph TD
    subgraph DONT["❌ DON'T"]
        DN1["主会话直接调<br/>codegraph_context ❌"]
        DN2["把 context 结果<br/>塞进主会话 ❌"]
        DN3["WASM 后端赖着不修<br/>（慢 5-10 倍）❌"]
    end

    style DONT fill:#fab1a0,stroke:#e17055

常见问题速查

症状	病因	解药
"CodeGraph not initialized"	项目还没初始化	`codegraph init -i`
索引特别慢	node_modules 没排除	检查 `.codegraph/config.json` 的 exclude
`Backend: wasm`	缺 C 编译工具	`xcode-select --install` + `npm rebuild better-sqlite3`
某些符号搜不到	文件被 exclude 或语言不支持	检查 config 和语言支持列表
MCP 连不上	项目未初始化或路径不对	`codegraph serve --mcp` 手动测试

配置文件参考

{
  "version": 1,
  "languages": ["typescript", "javascript"],
  "exclude": ["node_modules/**", "dist/**", "build/**", "*.min.js", ".git/**"],
  "frameworks": [],
  "maxFileSize": 1048576,
  "extractDocstrings": true,
  "trackCallSites": true
}

把 node_modules、dist、build 排除掉，索引速度能快几十倍。你肯定不想给 node_modules 里的 5 万个文件建索引对吧？

九、CodeGraph vs CodeGraphContext：不是一个爹生的

很多人在 GitHub 上搜 "CodeGraph" 会搜出两个项目，这俩名字像但完全不是一个东西：

维度	CodeGraph (colbymchenry)	CodeGraphContext (Shashankss1205)
Stars	5,200+	3,300+
语言	TypeScript (95%)	Python (73%)
数据库	SQLite（单一）	KuzuDB / Neo4j / FalkorDB... 6 种可选
安装	`npx @colbymchenry/codegraph`	`pip install codegraphcontext`
可视化	无内置	交互式 HTML（力导向图）
代码质量	不涉及	圈复杂度 + 死代码检测
定位	为 AI Agent 极致优化探索速度	CLI + MCP 双模，兼顾人类和 AI
路由识别	13 种框架	未明确

一句话选型：如果你主要用 Claude Code / Cursor，无脑选 CodeGraph。如果你需要可视化 + 代码质量分析，看看 CodeGraphContext。

十、总结

graph LR
    subgraph 问题["😫 三大痛点"]
        P1["Agent 反复 grep/read<br/>效率极低"]
        P2["改代码不知影响范围<br/>心惊胆战"]
        P3["Token 浪费在"发现"上<br/>而非"创造"上"]
    end

    subgraph 方案["🔧 CodeGraph"]
        SOL["预索引代码知识图谱<br/>把代码库变成图数据库"]
    end

    subgraph 结果["🎉 实际效果"]
        R1["工具调用 ↓ 92%"]
        R2["探索速度 ↑ 71%"]
        R3["文件读取 → 0 次"]
        R4["Token 节省 ≈ 30%"]
    end

    问题 -->|"驱动需求"| 方案
    方案 -->|"交付价值"| 结果

    style 问题 fill:#ffeaa7,stroke:#fdcb6e
    style 方案 fill:#6c5ce7,stroke:#5a4bd1,color:#fff
    style 结果 fill:#00b894,stroke:#00a381,color:#fff

要不要装？

如果你满足以下任一条件，立刻装：

用 Claude Code / Cursor / Codex 做日常开发
项目超过 100 个文件，grep 已经不够用了
改代码前经常担心"会不会把别的地方搞崩"
想省 Token（毕竟 Token = 钱）

如果你是以下情况，可以缓缓：

项目很小（< 20 个文件），grep 够用
只用 AI 做代码补全，不问项目级问题
网络隔离环境且在 Windows 上（WASM 回退确实慢）

最后说一句

CodeGraph 是那种 "装上就回不去" 的工具。它不做你代码中看得见的功能，它做的事很"幕后"——让你的 AI 助手变聪明 10 倍，而你自己甚至感觉不到它的存在。

就像你不会意识到搜索引擎的索引有多牛，直到有一天它挂了。

📎 相关链接

GitHub: colbymchenry/codegraph — 5.2K+ Star，MIT 开源

CodeGraphContext/CodeGraphContext — Python 实现，3.3K+ Star

npm: @colbymchenry/codegraph — v0.7.9