RAG已死?不,是Grep回归了!


这一年“RAG 已死”的说法甚嚣尘上,比如《长上下文窗口、Agent 崛起,RAG 已死?》、《The RAG Obituary: Killed by Agents》。而像 Claude Code、Codex 这类新一代 Agent CLI 也纷纷放弃了 embedding,官方直接承认:不建索引、不用向量库,靠 LLM 驱动 Grep 就够用。RAG 真的不适合现在的 Agent 了吗?围绕这个问题,我们展开了深入调研,同时对Claude Code 等前沿解决方案的源码进行了拆解,最终形成本文力求回答 RAG 在 Agent 时代是否还有一席之地这一核心关切点。




01



从Claude Code 的 Grep 说起


Claude Code 的创建者 Boris Cherny 在多个公开场合提到过这个让很多人意外的事实:Claude Code 不用 RAG,不用 embedding,不建索引。 核心搜索靠 LLM 驱动 Grep (Grep 是 Unix 下的文本搜索工具,给一个正则表达式,它就在文件里逐行找匹配)。


在 X/Twitter 上,他说得很直接:

“Early versions of Claude Code used RAG + a local vector db, but we found pretty quickly that agentic search generally works better. (早期版本的 Claude 代码使用了 RAG 加上本地向量数据库,但我们很快发现,智能体式的搜索通常效果更好)”


在 Pragmatic Engineer 的采访中更进一步:

“Plain glob and grep, driven by the model, beat everything. (由模型驱动的 glob 和 grep 击败了一切)”


Anthropic 官方的 Context Engineering 博客也确认了这一架构:Claude Code 使用 Grep 和 Glob 将代码动态加载到 context 中。这个选择不是拍脑袋做的,Boris 在 Pragmatic Engineer 的采访 中提到,他在 Meta 时观察到 Instagram 工程师在 IDE 的 click-to-definition 功能崩溃后,所有人都回退到手动 Grep 搜代码。不过他也在 Latent Space 播客 中坦承,放弃 RAG 的决策部分基于直觉。尽管 Anthropic 说了不用 RAG,用 agentic search + Grep,但 Grep 具体怎么调用、LLM 怎么决定搜什么、工具调用循环长什么样,这些实现细节都没有公开。


2026 年 3 月,Claude Code CLI 的一份源码快照因泄露被公开。我去看了一下,发现确实如 Boris 所说,源码中没有任何 embedding、vector、similarity search 相关的实现。但更有意思的是这套零索引内容搜索机制的具体实现方式。


这篇文章就是基于这份源码以及一些行业实践,从实现层面拆解 Claude Code 的代码搜索机制以及其背后的设计哲学。本文先拆解 Claude Code 如何驱动多轮 Grep 循环(第二章),再看暴力搜索为什么在本地项目上够快(第三章),最后和 Cursor 等行业方案对比,讨论 Grep 方案的真实成本与收益(第四章)。为了让整套机制不停留在抽象层面,我们用一个贯穿全文的例子来看。Claude Code 除了终端 CLI 模式外,还有网页版和桌面版,而这些模式下它通过一个叫 bridge 的远程控制系统运行,由服务端 session 执行实际工作。假设你在读这份源码时产生了一个好奇:当 LLM 调用 GrepTool 做搜索时,bridge 是怎么追踪和记录这次工具调用的? 你让 Claude Code 帮你从源码中找答案,接下来会发生什么?




02



LLM 驱动的多轮循环搜索机制


Claude Code 的代码搜索可以用一句话概括:LLM 自己决定搜什么、用什么工具搜、搜到后要不要继续搜,直到信息充分为止。 没有预设的搜索流程,没有固定的工具调用顺序,一切由 LLM 在运行时决定。这一章先讲搜索循环怎么运转、循环里有哪些工具可用,然后深入最核心的 GrepTool 看它怎么控制返回的信息量。最后用开篇提出的那个实战问题,完整走一遍多轮搜索的过程。


   2.1 搜索循环与工具


整套搜索机制的核心是一个循环:将用户输入和可用工具列表传给 LLM,LLM 返回文本或工具调用请求。如果是工具调用,执行工具后把结果追加到对话历史,然后带着更新后的完整历史再次调用 LLM。LLM 基于不断增长的上下文决定下一步做什么,直到它认为信息充分、直接生成文本回答而不再调用工具,循环自然结束。循环也有强制退出机制:达到最大轮次上限、超出预算限制、用户中断、或工具调用被权限拒绝。



这个循环对所有工具是平等的。LLM 可以在任何时候调用任何工具,甚至在一次响应中同时调多个。没有硬编码的“必须先搜再读”。与代码搜索相关的核心工具有四个:


工具

底层实现

作用

GrepTool

ripgrep (rg)

正则搜索文件内容

GlobTool

glob 模式匹配

按文件名/路径模式查找文件

FileReadTool

Node.js fs

读取指定文件的指定行范围

AgentTool

独立 LLM 对话

启动子 agent 做多步探索


此外还有 LSP(Language Server Protocol)工具,用 “go to definition”、“find references” 等语义精确的操作补充 Grep 的不足。但核心搜索架构建立在这四个工具之上。


其中 AgentTool 比较特殊:它不是直接搜索文件,而是启动一个独立的子 agent,让子 agent 在自己的 context window 里完成一整套搜索任务,最后只把结论返回给主对话。子 agent 有多种类型,与搜索最相关的是 Explore 类型:它只配备搜索和读取工具(Grep、Glob、Read),不能编辑文件、不能执行命令、不能嵌套启动新的 Agent,是一个纯只读的搜索专家。


子 agent 的核心价值是 context 隔离。它从零开始构建自己的对话历史,不继承主对话的消息,这意味着它搜索过程中产生的大量 grep 结果、代码片段都留在自己的 context 里,主对话只收到一段总结性的文本结论。对于需要大范围搜索的任务,如果在主对话里直接搜索,几轮 grep/read 下来 context 可能就被中间结果塞满了。因此交给子 agent 处理后,主对话的 context 只增加一条结论消息。


   2.2 GrepTool 的信息量控制


在一般实践中,LLM 最常用的模式是“先定位,再深入”:先用 Grep/Glob 找到相关文件,再用 Read 读具体内容。但 Grep 搜到文件后,是不是每次都要接一个 Read 才能用?不一定。关键在于 GrepTool 有三种输出模式,返回的信息量完全不同:

  • files_with_matches 模式(默认):只返回匹配的文件路径列表,不返回任何代码内容。比如搜 "class.*Transport" 会返回 cli/transports/WebSocketTransport.ts、cli/transports/SSETransport.ts 这样的路径。LLM 拿到的只有文件名,所以这种模式下通常需要接 Read 才能看到具体代码。这也是为什么默认模式设计成只返回文件名,即故意控制信息量,避免一次 Grep 就把大量代码涌入 context window,让 LLM 自己判断哪些文件值得深入读取。另外还有一个保护机制:head_limit 默认 250,即使搜到 10,000 条匹配也只返回前 250 条,防止搜索结果淹没 context。

  • content 模式:返回匹配行及其上下文代码。比如 Grep({pattern: "TOOL_VERBS", output_mode: "content", "-C": 5}) 会直接返回匹配行前后各 5 行的代码片段。对于很多场景,例如确认一个常量的值、看一个函数签名、检查某个 import 是否存在,这些片段就够了,不需要再 Read 整个文件。

  • count 模式:只返回每个文件的匹配数量,用于快速评估搜索词在项目中的分布密度,不返回具体内容。


所以实际的工具组合方式是灵活的:Grep(默认模式)→ Read 是最常见的路径,但 Grep(content 模式)可以独立使用,LLM 也可以直接调 Read(如果已经知道文件路径),或者一次同时发起多个 Grep 并行搜索。这种灵活性是有意为之。其思想是用软引导代替硬约束:system prompt 建议 LLM 先 Grep 定位再 Read 深入,GrepTool 的默认输出模式也自然引导这个流程,但不在代码里堵死其他路径,让 LLM 根据具体情况做判断。


   2.3 实战:追踪搜索工具的执行记录


回到开篇的例子。当然这个问题是我刻意挑的,因为答案分散在多个文件中,需要多轮搜索才能拼出全貌,目的是展示多轮搜索的完整过程。我把这个问题抛给了 Claude Code,以下是真实的搜索过程。


第 1 轮:广撒网。 LLM 把问题中的 GrepTool 和 追踪 翻译成 grep 关键词,用默认的 files_with_matches 模式扫一遍:

Grep({pattern: "GrepTool|tool.*track|tool.*activity", glob: "*.ts"})→ 返回 4 个文件:structuredIO.ts, sessionRunner.ts, bridgeUI.ts, bridgeStatusUtil.ts


4 个文件,其中 3 个在 bridge/ 目录下,1 个在 cli/ 下。问题问的是 bridge 系统,LLM 关注 bridge/ 下的文件。sessionRunner.ts(session + runner = 会话执行器)最可能包含工具执行追踪逻辑。



第 2 轮:看上下文。Grep 切换到 content 模式,看 GrepTool 在 sessionRunner.ts 中的上下文:

Grep({pattern: "GrepTool|tool.*activity", path: "bridge/sessionRunner.ts", output_mode: "content", "-C": 5})


返回的代码片段中能看到一张映射表的尾部,显示 GrepTool: 'Searching'、BashTool: 'Running',但上文被截断了。LLM 判断需要 Read 整段代码才能看全。



第 3 轮:调用Read。 使用 Read 打开 sessionRunner.ts 的完整上下文,一次看到了三个关键结构:

  • 第一个是工具名→动词映射表(TOOL_VERBS,共 18 个条目,这里列出与搜索相关的部分)。每个搜索工具(Grep、Glob)在这里都被映射成 Searching。注意有两套命名,比如内部名 Grep 和外部 SDK 名 GrepTool。这表明工具名是硬编码在映射表里的,不是动态注册的。

Grep: 'Searching',   GrepTool: 'Searching',Glob: 'Searching',   GlobTool: 'Searching',Read: 'Reading',      FileReadTool: 'Reading',Edit: 'Editing',      FileEditTool: 'Editing',Bash: 'Running',      BashTool: 'Running',// 还有 Write, MultiEdit, WebFetch, WebSearch, Task, NotebookEditTool, LSP 等
  • 第二个是摘要生成函数,它把动词和搜索目标拼接在一起:动词来自上面的映射表,目标则从工具调用的输入中提取(优先取 file_path,其次 pattern、command、url 等)。所以一次 GrepTool({pattern: "reconnect|backoff"}) 调用的摘要就是 Searching reconnect|backoff。

  • 第三个是活动解析器:它从 session 的 stdout 中逐行解析 JSON,当发现工具调用事件时,调用上面的摘要函数生成摘要,打包成一条活动事件。


到这里已经知道了怎么追踪和怎么记录,但活动事件生成之后去了哪里?



第 4 轮:追踪使用方。 Grep 搜 SessionActivity 被谁引用,一次追出整条链:

Grep({pattern: "SessionActivity|currentActivity", path: "bridge/", output_mode: "content", "-C": 2})


三个文件同时浮出水面:

  • bridge/types.ts :活动事件的类型定义,只有 3 个字段(类型、摘要、时间戳)。每个 session 维护一个环形缓冲区和一个当前活动指针。

  • bridge/bridgeMain.ts :一个定时器周期性轮询每个 session 的当前活动,并维护最近 5 次工具调用的轨迹,例如 Searching → Reading → Searching → Editing 这样的历史。

  • bridge/bridgeUI.ts :收到工具启动事件后,缓存摘要文字并渲染到 bridge 的状态面板。


这样就拼出了完整的追踪链:session 进程输出工具调用的 JSON → 活动解析器提取并生成摘要 → bridge 主进程定时轮询获取最新活动 → UI 模块渲染到状态面板。





03



性能原理:暴力搜索为什么够快


上一章展示了 Claude Code 如何用多轮 Grep 搜索代码。但这引出一个显而易见的问题:每轮 Grep 都是在项目文件中暴力扫描。一个大一点的项目可能有几万个文件,暴力扫描不会慢吗?


Grep 在今天是一个大家族。诞生于 1973 年的 GNU grep 是最经典的版本,逐文件递归、不认识 .gitignore、默认单线程。而 Claude Code 的 GrepTool 底层调的并不是它,而是 ripgrep,在2016 年由 Andrew Gallant 用 Rust 重写的现代实现,默认遵守 .gitignore、自动跳过二进制文件、多线程并行、用 SIMD 加速匹配,为在大型代码库里快速搜索这个场景从头设计。


源码佐证:tools/GrepTool/GrepTool.ts:21 里 import { ripGrep } from '../../utils/ripgrep.js' ,所以真正干活的是 ripgrep,不是系统自带的 grep。


这一章解释为什么 ripgrep 的暴力扫描在开发者本地项目上足够快:五层过滤怎么把搜索范围从几万文件缩小到几十个,SIMD 和 Boyer-Moore 怎么加速文件内匹配,以及代码搜索和向量检索在数据规模上的本质差异。3.4 节还有一组用 Claude Code 自己的源码做的 ripgrep vs GNU grep 实测数据,可以直接看到差距。


   3.1 ripgrep 的五层过滤


ripgrep 不是对每个文件都做正则匹配。它在真正搜索内容之前,有多层过滤逐步缩小范围:

层级1: 目录级剪枝(.gitignore)  — 跳过整棵目录子树,连目录内容都不读取层级2: 路径范围限制(path 参数)  — 限定目录遍历的起点层级3: 文件类型过滤(glob 参数)  — 遍历目录但跳过不匹配文件层级4: 二进制文件检测            — 读文件头几个字节,发现是二进制就跳过层级5: 内容搜索(正则匹配)      — 最后才对通过所有过滤的文件做匹配


各层过滤是乘法叠加的。回到我们贯穿全文的例子,第 4 轮搜索 Grep({pattern: "SessionActivity|currentActivity", path: "bridge/", glob: "*.ts"})。在泄露的 Claude Code 源码(4,471 个文件)上,实际的过滤链是:

原始文件数:                 4,471层级1 .gitignore 剪枝:     → 4,471  (源码快照无 node_modules,此层无效果)层级2 path 限制 bridge/:   → 32     (只遍历 bridge/ 目录)层级3 glob *.ts 过滤:      → 32     (bridge/ 下全是 .ts,此层无额外过滤)层级4 二进制检测:           → 32     (全是文本文件)层级5 正则匹配:            → 3 个文件命中(bridgeStatusUtil.ts、sessionRunner.ts、bridgeUI.ts)



这个例子中 path 限制是最大的过滤器,一步从 4,471 砍到 32。但如果是一个包含 node_modules/ 的完整 Node.js 项目,.gitignore 剪枝的效果更大。因为一个典型项目中 node_modules/ 可能包含数万个文件,一条规则就砍掉大量的文件数量。


   3.2 文件内搜索的加速手段


通过过滤后需要实际搜索的文件,ripgrep 在内容匹配层面也有多项优化:

  • SIMD 向量化匹配。 ripgrep 底层使用 Rust 的 regex crate,它利用 CPU 的 SIMD 指令并行比较字节。普通逐字节比较一次处理 1 个字节,AVX2 一次处理 32 个字节。搜索时先用 SIMD 快速扫描搜索词首字符的出现位置,只在命中时才做完整匹配。对于多模式搜索,ripgrep 使用 Teddy 算法实现 SIMD 级别的多模式并行匹配。

  • Boyer-Moore 跳跃。 对于固定字符串搜索,从 pattern 末尾开始比对,遇到不匹配时根据 bad character table 直接跳过多个字符。长 pattern 时只需扫描约 n/m 个字符(n = 文件大小,m = pattern 长度)。

  • 操作系统 Page Cache。 读过的文件内容会被操作系统缓存在内存中。对于经常使用的代码项目,文件几乎永远在缓存中。首次搜索可能触发磁盘 I/O,第二次搜索直接从内存返回。

  • mmap 零拷贝。 对于大文件,ripgrep 使用 mmap(内存映射)代替普通的 read() 系统调用。普通 read() 需要将数据从内核空间复制到用户空间,mmap 让进程直接访问内核的 Page Cache,省掉一次数据复制。对小文件反而因为系统调用开销不划算,所以 ripgrep 会根据文件大小动态选择。

  • 多线程并行。 ripgrep 用线程池并行处理多个文件:一个线程遍历目录树产出文件路径,多个 worker 线程并行搜索不同文件,结果通过 lock-free queue 汇总。


   3.3 性能实测数据


用 Claude Code 自己的源码(4,500 文件、95 万行代码)做一组实测,对比 ripgrep 和 GNU grep 在同一台机器上搜索同一个关键词的耗时(取 3 次运行的稳定值):

搜索模式

ripgrep

GNU grep -r

倍数

TOOL_VERBS(低频词)

0.09s

2.55s

28x

async.*generator(正则)

0.10s

3.30s

33x

import.*from(高频词)

0.10s

2.45s

25x


两者搜索的文件范围几乎一样(ripgrep 4,494 个文件 vs GNU grep 4,522 个),差距主要来自 ripgrep 的多线程并行和 SIMD 向量化加速,而非文件过滤。0.1 秒的搜索延迟对交互式使用来说基本无感。


   3.4 数据规模有限度


一个很重要的原因,Claude Code 面对的数据规模(开发者本地项目)恰好落在暴力搜索可行的范围内。


向量检索

Grep

常见场景数据量

GB ~ 

MB ~ 几百 MB

单次比较成本

768 次浮点乘法(余弦相似度)

1 次字节相等判断

SIMD 加速后

~24 次乘法/指令

~32 次比较/指令

暴力扫描总耗时

秒 ~ 分钟

数十毫秒


一个 250MB 的代码库在 Page Cache 命中(开发者的日常项目几乎总是命中)的情况下,连磁盘 I/O 都省了,整份数据就躺在内存里。按现代开发机约 30GB/s 的内存带宽算,把这 250MB 从 page cache 搬一遍的数据搬运下界约为 250MB / 30GB/s ≈ 8 毫秒。真实情况下还要加上 ripg…

— 以上为试看内容(约 40%),开通会员后阅读全文 —