cdex如何压缩上下文
各位技术大牛好，今天我们聊一个极其硬核且痛点满满的话题，大模型的上下文压缩。我们都用过所谓两百 k 甚至一 m 窗口的模型，但真正在生产环境跑过复杂 agent 的 人都知道，长窗口根本不是银弹。今天我们将拆解行业最前沿的上下文管理机制。 这是一个非常反直觉的真相，很多开发者单纯依赖硬件层面的长窗口，觉得把所有历史记录塞进去就完事了。但现实是，超过一定的 token 水位线模型不仅会犯错，还会产生极高的延迟和成本。这就是为什么头部大厂都在悄悄转向另一种策略。 为什么我们需要专门做上下文压缩。左边是我们过去常用的滑动窗口策略，也就是硬截断。这就像一个失忆症患者，走着走着把出发的目的忘了。而右边行业正在转向语义压缩，他的目标不是简单的扔掉数据，而是提炼出核心事实，让有效对话长度直接翻十倍。 接下来我们先明确一下什么是上下文压缩，以及他在工程上到底解决了什么具体问题。 举个最具体的例子，你让 agent 帮你重构代码干了三个小时，前三十分钟定好的数据库表结构， 到了第三个小时，因为 token 满了，早期对话被硬生生切掉，结果 agent 突突然开始凭空捏造自断。这种挫败感写过复杂 agent 的 的人一定懂，这就是 context route 带来的灾难。 我们用数据流图来看这个过程，用户的核心意图在最开始进入工作记忆，但随后大量的工具调用日制报错信息像洪水一样灌进来， 一旦触及两百 k 限制，系统被迫驱逐最早的规则，直接导致最终的幻觉。我们要干掉的就是中间这个被动驱逐的环节。这是一个清晰的对比 应阶段，虽然在计算上几乎零开销，但对于长周期任务是致命的。语义压缩虽然需要消耗一次额外的 l l m 调用来做总结，但它能把早期定下的基调约束和当前进度浓缩成一段系统提示词保留在上下文中。 这就好比你在交接工作时，给继任者留了一份详尽的文档，而不是直接走人。我们快速停顿一下，答案显然是 b。 其实，羽翼压缩再触发的那一瞬间，并不会帮你省钱，甚至还要花钱去跑一次摘药模型。它的核心价值在于保命，保住整个推理链路和业务规则不崩盘。如果这点达成了共识，我们进入深水区。 既然羽翼压缩这么重要，大厂和主流框架在底层，到底是怎么实现它的？我们来拆解它的三层核心技术架构。 行业里目前有三大流派并存，第一种是全量羽翼摘药，简单粗暴但有效。第二种是像外科手术一样，只切除无用的容肠锐志保留对话。第三种则是学术界和顶尖实验室正在搞的 u t a c a。 基于模型生成时的不确定性动态调整窗口，我们逐一来看 什么时候触发压缩最合适。传统的做法是设一个死线，比如一百八十 k 触线就压，但这很生硬。现在的高级 agent， 比如 long chain deep agents， 采用的是机会主义触发，也就是在任务的自然边界，比如刚写完一个文件，或者刚查完一个资料， 趁着逻辑闭环，顺手把前面的废话压缩掉，这才是真正的高级感。给各位工程师透个底，这是目前行业里几家头部框架和模型的预值设定。 lion king 比较保守，百分之八十五就开始动手了， openai 的 c i i 工具敢推到百分之九十五，而 clark 三点七 sonic 官方给的最佳实践是在一百五十 k 左右进行拦截和压缩，记住这些数字调餐时能省很多事。 这里要讲一个最前沿的 utac 机制，它的底层逻辑非常惊艳，模型在逐字生成 token 时，系统会实时监控它的 legit 边缘差值。如果发现模型不够自信，有幻觉风险，系统会立刻触发回滚机制，把上下文窗口拉大，解锁更多精确信息塞进去，然后再重新生成。 这是一种极其精密的动态内存管理理论。讲完了，我们来看看大厂在工程上是怎么把这些概念落地的，直接上代码和架构 antropic 在 cloud api 里直接做了一个 beta 版的特性，你只要传一个 compaction strategy 进去，设定域值到了一百五十 k， api 服务器会在底层自动帮你做总结阶段。注意，这里有个极其关键的参数， pause after compaction， 它会在生成招标后暂停，把控制权交还给你。 来看 slide 十六的核心 forgot 是 怎么做的，它不光看 token， 还看对话轮次，最绝的是右边这个推理链保留。 对于像 cloud 三点七这种具备深度思考能力的模型，如果你把它的历史思考过程直接暴力压缩掉它，接下来的回答就会像断片一样失去逻辑连贯性。所以 forge code 会特意把最近的推理过程提取出来，像接力棒一样塞给下一轮对话。 这是 forge code 的 实际配置文件。看到 preserve reasoning true 和下面的 reasoning text 了吗？在执行压缩时，框架会扫描被淘汰的历史消息，用正则或者解析器把这些 dot 标签里的内容抠出来， 强制附加到新的上下文中，这就是资深工程师解决问题的优雅方式。并非所有的压缩都要动用 l l m 去写小作文，像 open code 这种工具采用的是外科手术室的修剪。写代码时最占 tok 的是什么？是那些动辄几万行的报错日制和 get diff。 open code 会直接把历史轮次里的长日制删掉，只保留最新一次的报错，这既省了 tok， 又完全不破坏对话语义。 检查一下大家的专注度，答案是， b 服务器帮你做完 java 后暂停，是为了让你有机会把最近几轮及其关键的对话，或者你系统里特有的上下文对象原封不动地拼接到 java 后面，然后再让模型继续回答，这赋予了开发者极大的控制权。 看到这里，你可能觉得上下文压缩很完美，但作为 staff 级别的工程师，我们必须看到它在实际落地时的暗坑和 trade offs。 这是所有压缩算法面临的终极矛盾。做招标必然丢失细节。对闲聊机器人来说，保留大意就够了。但对于写代码的 agent， 如果压缩时把某个特定函数的入参类型给概括没了，接下来的代码全得报错。 所以在复杂的分析场景中，纯摘要是危险的，必须配合我们前面讲的修剪和推理保留策略。这里有个极容易踩坑的工程细节，你为了监控一百八十 k 的 域值，如果在每次请求前都把几十万字的上下文扔进 tokyo 字儿算一遍，你的系统延迟会直接爆炸。 大厂的做法是使用 loggerimac sampling 对 数参照或者基于字母长度做快速计算，只在逼近红线时才做精确计算。这是一个非常实用的性能优化点。 另一个深水区是 k v cash， 你 辛辛苦苦积累的上下文缓存，一旦执行压缩，历史内容变了，缓存直接失效，下一次请求会慢得像蜗牛。解决办法是利用大模型 api 的 cash breakpoints 特性，把系统提示词、核心文档放在最顶端并锁定缓存， 不管下面怎么压缩，顶部的缓存永远生效。学术界对上下文管理有一个著名的论断，叫做苦涩的教训。 他告诉我们，不要试图用极其复杂死板的硬编码规则去管理模型的记忆，把压缩上下文封装成一个托儿交给大模型，让他在觉得脑容量不够用的时候，自己调用工具清理自己的记忆，这才是未来的终极形态。 最后，我们站在现在，看未来下一代向下文管理技术会往哪个方向引进。 未来的方向非常明确，混合优化与软硬协调。软件层面，我们会把量化技术和语义压缩结合起来，不重要的历史记录不仅被总结，甚至在显存里直接被降级为四倍的存储。 硬件层面，未来的 ai 芯片会像现代操作系统的虚拟内存一样原生，支持 kvatch 的 快速换页和淘汰 快速复习。以下今天涉及的三个核心黑化， semantic compression 是 我们的核心武器， u t s o a 是 未来动态分配的终极形态，而 retention window 是 你在写配置时，为了保证最近对话不出现断层，必须设定好的保留参数。 总结一下今天的核心洞察，上下文压缩绝不是写一个拍档脚本截断数组那么简单，它正在从一种被动的防御机制演变成由 a 阵自主驱动的具备推理链保留能力的基础设施及组建。这是从死记硬背到懂得规范的进化。 这句话是我希望大家带走的。硬件的二百 k 只是物理极限，但通过优秀的上下文管理工程，你可以让 a 阵的跑完相当于两千 k 的 超长任务而不会崩溃，这就是工程架构的魅力。 落地建议回去立刻看一眼你们公司的 agent 业务，如果还在用无脑的数组切片做硬截断，赶紧把它换成基于总结和修剪的混合策略，特别是涉及到深度思考的模型，一定要把它的 reasoning thought 提取并保留下来。感谢各位的时间，我们下期硬核技术拆解，再见！
粉丝6218获赞3.6万
相关视频
00:08查看AI文稿AI文稿你的 codex 压缩上下文的时候是不是经常卡死？教你一招，用五点三来压缩，然后再切回五点五， ok。
40山海有灵AI
06:05查看AI文稿AI文稿给大家来介绍一下那个 treble count， 上次我们给大家介绍过的怎么把 k v catch 做压缩，在相同的这个显存里面，可以让上下文的能力可以扩展到四倍，它是一个在线的 k v catch 压缩的算法。之前我们也给大家介绍过这个论文， google 去搜索他们发布的这样一个论文，目前在开源项目里面，在 v l l m 的 这个大模型推理的开源框架里面，目前它上周已经把它给实现出来了，当然这个实现它还不是一个完全版本，它目前 像通一千万三点五的模型，目前还不支持，因为它是属于混合 transform 跟 member 架构的这种 k v catch 它会比较复杂，所以它还还在实施中，要要支持这个混合模型的这样的一个 tobacon 的 这样一个量化，它可能还要还在开发中，但是一般的模型它不是这种混合架构的，目前已经这个功能已经合并到主干上面，大家可以来进行测试了。我们首先先给大家看一看啊它的整体的实现，我们看看它是怎么做的。首先我们看这张图啊，这张图里面简单的来讲，主要我们 transform 架构里面有 k 向量和 v 向量， k 向量它是用了一种压缩算法，它这里面讲了先通过叫 w h w h t 的 这样一个旋转，再经过这样的一个量化，再经过这个方法的量化，再缓存到它的 catch 里面，这样它会把这个像我们视频压缩一样，它会把这个数据就会压缩的比较小。还有一个 v 向量，它就用这个 我们称之为叫归一化的这样的一个量化，它就直接把它给压缩，也是一样放到这个 catch 里面去，这个是我们称之为叫，这个就是存储 kv catch 存储过程，当我们要解码的时候，那么我们就需要把这个 kv catch 压缩完的 kv catch， 通过这样的一个 catch 把它给拿出来之后，再要经过叫解压的这个过程反量化的这样一个过程，反量化它就会变成这个 qkv， 再经过这个 qkv 去算它的头肯的 这样的一个东西，这个是它的整个一个算法，那么它在 vr 里面还有一个过程，就是叫预填充，预填充它是直接用那个 flash attention 直接的去计算它的 output， 那 这样它的性能会更好一些。它是怎么来看的？ 就这个是它整个一个实现的架构，我们发现它的实现的方法跟我们之前的论文里面还是有些差异的， 这个地方大家来介绍一下它这个差异主要还是讲的是什么呢？第一个它是用了叫 w h t 的 这个旋转去替代 q r 这个分解的随机正交矩阵，通过这个方法效率会更高一些。另外它把五 五个操作变成一个，合并成一个，却成的这样的一个柯诺的一个算子，所以它效率会更高。另外它也压缩了这样的一个叫 内存的这样的一个 size， 去减少百分之四十七的内存的浪费，这个是他最主要的，他在里面也发现他们社区在实践里面也发现，相对来讲 vivo 的 精度对推理质量是非常关键的，这个是 vivo vivo 的 量化，你到底用四比特还是用三比特还是用二比特？其实他这个值 对他后面的这样的一个推理的这样一个精度来讲是影响是非常大的。社区他们发现就算你这个值， 这个 vivo 的 这个值被压缩之后，你的相似性跟原来有百分之九十九的相似性，但是如果他的这个比特比较低的话，他也会造成这个模型的性能显著下降，你可以看到这个三比特跟四比特 还是有一个比较大的差异，所以一般建议是用四比特的这样一个 vivo 量化方式，用四比特的这种量化方式，通过归一化之后再进行矫正，或者他这个地方就直接用了一个归一化，那也可以 它 k， 它目前实现了也有几种方式，一种原始的 f p 八，另外一种就用一个四比特的一个军方叉做了一个量化，当然也做了一个 n c 的 一个矫正。三比特影响不是太大，这个影响不是太大，主要是这个 view 的 值，它可能 对后面的推理影响会比较大，那所以我一般用到这个程度就足够了用，用到这个程度是已经够了，或者用这种方式两种 k v catch 的 这种方式，在 vm 里面用这两种方式相对来讲也会比较简单，只要你在模型的这个启动参数里面，你增加这个叫 k v catch e type， 只要你用这个值就可以了。 turbo count k 八 v 四，或者你可以用 turbo count k 三 v 四杠 nc 那 么两个效果，它只是压缩率最好 第一个方法，它的压缩率虽然只有二点六倍，但是它的性能，它对这个推理的性能吞吐量影响是最小的，它在这个里面他们做了一个实验，用英伟达的 rtx pro 六千酷尔的这个芯片去运行通一千万三杠四 b 的 模型，它去比较各种各样的场景，比较少的 短输出，比较长，这个是长输入的 profile， 这个是比较平衡的或者高负荷的这个情况，它测了各种各样的情况，我们可以发现这个 k 八 v 四，就 k 八 v 四的这个方式，它有些时候，特别是在长上下文的这样的一个 场景下，它的性能反而要比贝斯拉要更好。所以我们可以看到它的这个算法，就是昂兰的这样的一个半程压缩算算算法，其实它对吞吐量它其实也是有提高，或者是对延迟是有降低的，也是一个非常不错的非常长的上下文。因为我们现在运行 不管是 ai 写代码，还是要 ig 还是多轮对话，一般情况都是一个长上下文的这样的一个推理过程啊。所以用这种 k 八比四的这个算法会比较优，它可以让我们的上下文可以增加二点六倍压缩，同时它的吞吐量也能达到至少百分之八十到百分之一百，这样的一个吞吐量延迟会更低一点。 这个是给大家就介绍一下，这个是他的命令，你可以看到他用起来还是非常简单的，目前他主要是支持通一千万三之前的这个模型，他几乎都能支持。如果是 像通一千万三点五后或者最新发布的三点六，可能要过一阵子他才能去支持。这个功能应该来讲是非常重要的，非常好的这样一个功能，可以让我们的显存可以更少，支持模型的上下文可以更大。 这个 v l m 里面的这个功能就是 supercon 的 这样一个在线 k v touch 的 一个缓存压缩的这样一个功能，我们就展示给大家，就介绍到这，下次如果等这个 v l m 正式发布这个功能之后，我们再给大家再来评测一下啊。好，今天我们这样一个视频就给大家就介绍到这。
37小工蚁
03:40查看AI文稿AI文稿好，大家好，我是小刘。呃，今天我们一起来聊一下在 codex 中上下文管理的一些技巧，那这里呢，我会讲我平时在使用 codex 当中，我是怎样进行上下文管理的。那我们先说一下背景， 什么上下文管理呢？就是我们知道我们在一次对话的过程当中，它的绘画窗口是有限的，可以看到这里是共二百五十八 k， 那 已经使用了三十二 k， 当这个上下文满的时候呢，扣代码，它会自动的压缩这个背景，这样呢我们的这个整个上下文会失真。什么是压缩背景呢？比如说猫和老鼠四个字，那就是我们绘画的主要内容，他会把它压缩一下变成猫老鼠，你看是不是压缩了，对不对？ 但这样就会产生一个通病，就是产生 ai 幻觉，那也就是我们的功能开发会越用越不好用，你会发现你跟他说一个点，他就是不明白，然后呢会导致我们很崩溃。 那我们来看一下这个网友是怎么解决的，然后我再讲我自己的方案，他的方案就非常的简洁易懂，就我们都知道每一次对话呢，它会产生一个绘画的 id， 那 我们这次绘画它是存储到我们本地内存当中或者数据当中，这时候我们可以选择复制这绘画 id， 那 这个绘画 id 呢？本身上是一堆的这种字母，就我们扣带子可以根据这个字母找到我们当前上下我们所有对话， 他拿到绘画呢，可能是压缩库的，可能是不准确的，所以呢他就遇到了这个情况，他就把他哎复制到一个新的窗口当中，比如说新对话，这时候你看跟他说对吧？请你帮我进行这个功能继续开发是不是？那这个时候是不是就拿到了我们的青山崖纹？这个也可以，只是说开发的时候，那他需要去浪费更多的图层，因为他需要加载数据库，加一个内存，对吧？ 好，首先我先说一下我的方案，就是这里呢，我会回顾一个上下文的文档，进行定期的总结。举个例子，比如说像这个绘画呢，他都满了，那我就跟他说，请你帮我根据当前这一次的绘画呢进行总结出一个 markdown 文件，这个 markdown 文件呢是包含了这一次的一些所有的关键信息，那你可以看我思路这样的，请你帮助我， 请你总结当前项目的关键决策已经完成的部分和代办事项，便于我下次听话加的一定要加这句话，如果说你不加这句话，他给你的可能就是一个总结性的文档，如果说你加这句话的话，他会按照 call 代词能够处理的绘画格式给你一个哎，一个合理的 bug 档，所以就相当于固定的一个格式给他。那如果说，哎，我这时候跟他说这句话对不对？ 尽量用五点五模型，用最好的模型实现的效果可能是最好的。然后你比如说用五点五超高你发送一下，那这时候呢，他就会根据你当前的这个项目进行总结一个 bug 大 文件，那收下一次开启的时候呢，你就可以把这个 bug 大 文件哎给他 就是丢进去，然后这个时候呢，他就可以直接的进行上一次上下文的复用，而且呢失真不会失的很严重，那最起码会比直接使用 codex 压缩的方式会好一点，那这是我的第一种方法。第二个呢，就是使用这 codex 内置的压缩功能呢，这个我刚刚说过了，对吧？我们 正常来说 codex 也会进行自动压缩，但是它会进行四帧，但是进阶技巧就是我们可以直接让 codex 呢，每次都生成这个 prompt， 就是 给它设定一个这个啊， ajax， ajax， markdown， 这种，对吧？让它自动生成，而不是让我们手动去指定它。 那这里呢，再分享一下我自己的这个 codex 技巧，因为有小伙伴他会问我说，你视频当中平时使用 codex， 那 我先说我怎么使用呢？首先我不会把一个项目 丢到一个上下绘画里面，一个上下文绘画里面我会把它拆成多个小的功能，在每一个小的功能对应一个绘画，这样呢，我这个绘画可以赞成很大，并且呢它总结出一个 markdown 文件，再把这个 markdown 文件丢给一个新的绘画，这样呢，我们就基于这个功能在进行优化，不会去影响整个的大局。啊，能懂我意思吧？ 那第三种就是我们可以使用外部的持久化工具，那这个外部持久化工具有很多，比如像我们之前说的 context 上来说，就是把原先我们的 markdown 给它缔造了外部的这种 社区部里面去，你可以这么去理解，然后通过一些更好的方式去把它读取到这个 collect。 那 每一个开源项目都有自己的方式，大家可以自行研究，因为篇幅有限，所以我这里呢就讲这几种，好吧。 然后呢？呃，这种方式呢？其实我还是建议大家使用 bit 进行管理起来，因为当我们用 bit 进行管理起来之后，我们整个上下文呢，能够更加有链路的去回溯，就是每一个版本都有对应的回溯， 我们能够很清晰的看到，对吧？这是我们整个流程，你可以看到通过这样的方式，那就是像上下文的这个管理，好吧，这呢是。呃，好了，那以上就是本期视频的全部了呢，我是小刘，我们下期再见。
1023程序员晓刘![第111期丽姐的AI悄悄话-上集：Codex使用技巧第一弹，小白新手必看！
[技巧1 - 自动压缩会话]
[技巧2 - @键快速调用插件]
[技巧3 - Markdown渲染+注释]
[技巧4 - 海量插件即插即用]
#codex #AI #agent #编程入门 #软件分享](https://p3-pc-sign.douyinpic.com/image-cut-tos-priv/172629e0568ee588746ae17ca65686e1~tplv-dy-resize-origshort-autoq-75:330.jpeg?lk3s=138a59ce&x-expires=2099707200&x-signature=8mxEauHXeWTowsjGIUHNI%2BqBMPY%3D&from=327834062&s=PackSourceEnum_AWEME_DETAIL&se=false&sc=cover&biz_tag=pcweb_cover&l=202607181207218E0845F811A2F666C39F)
02:08查看AI文稿AI文稿你有没有遇到过这种崩溃 ai 对 话，越聊越长，上下文爆了，要手动清理！ ai 干活时突然想问一个问题，一，插嘴任务直接重置 在 codex 呢？这八个技巧让你的效率翻倍！欢迎来到新手村，今天给你分享 codex 的 八个使用技巧，学完从小白变老手！ 技巧一，自动压缩绘画什么意思呢？就是 ai 会自动整理上下文，把废话删掉，保留住精华，不用你去手动清理， 再也不用担心对话太长一出，也不用重新开绘画，用的越久越感觉这货是真懂我呀！技巧二，艾特键快速调用插件 想用插件别翻菜单了，直接敲 at 键，弹出一个插件列表，想用哪个 at 哪个，秒掉出来。不用记命令，不用查文档，手指头一敲，插件就位，这才是真正的一触即发。 技巧三， markdown 渲染加注式敲代码写文档的看过来， codex 原声支持 markdown 渲染，写出来的东西格式漂漂亮亮，阅读体验拉满 还不够？它还有两个小技能，第一个就是它可以一键还原原始 markdown， 想看原码随时切换。第二个就是给某段内容添加一个注视，精准标记问题所在，再也不用密密麻麻的文字里面大海捞针， 还可以精准地给这个 markdown 进行一个注视，然后在对话里面去让 codex 去帮你去修改，非常的便捷，更加的精准化的定位我们的问题。 第四个技巧就是海量插件，即插即用。 codex 呢？它默认支持很多插件，开箱即用，不用你折腾配置，不用你找安装包，点开就用 翻译插件、画图插件、数据分析插件等等，别人还在装环境，你已经开始开工了。好了，这一期就到这，下期我教你进阶技巧多现成自动化的骚操作，觉得有用的话点点关注点点赞，我们下期再见啦！
06:23查看AI文稿AI文稿面试官，上下文信息太长，如何有效地进行筛选与压缩，且保证正确率最大化？现在的模型长文本能力动不动就十几万上百万头肯，那为什么我们在做企业级 reg 或者对话系统的时候，还要费死劲去研究上下文压缩？ 直接全塞给模型不就完事了吗？如果你在面试中听到上下文信息太长，如何有效的进行筛选与压缩，且保证正确率最大化？这个问题千万别以为面试官是在靠你省钱。面试官之所以问这个， 本质上是在考察你对大模型底层缺陷的认知。 ai 大 模型学习资料可以在主页置顶群里。大家好，我是彭宇。你要知道，长文本虽然看似美好，但它有两个致命伤，第一是中间遗忘效应，也就是那篇著名的论文 lost in the middle 提到的 模型对 prompt 中间部分的信息感知力会大幅下降。第二是噪声干扰，也就是如果你塞进了一堆跟问题无关的废话，模型，就会产生严重的幻觉。所以上下文压缩不是一种节省， 而是一种对信噪比的极致追求。好，大家看这张架构图，我们要讲的第一层就是初筛召回层。大家思考一个场景，用户问二零二四年三月份公司关于 a 幺五型号产品的销售政策是什么？ 如果你只用普通的向量检测， vector search 系统可能会因为与 e 相似，把你拉到二零二三年或者关于 b 幺六型号的文档里。为什么？因为在向量空间里， a 幺五和 b 幺六的距离可能非常近，所以在第一层， 我们必须用混合搜索，也就是把 b m 二五这种传统的关键词搜索和向量检测结合起来。 b m 二五负责死磕 a 幺五和二零二四年三月这些硬指标，而向量检测负责抓语义。这一步就像是一个大筛子， 我们的目标是广撒网，定边界，把那百分之九十绝对不相关的垃圾信息先给它过滤掉。如果你这一步没做好，后面压的再精细也是白搭，因为根上就找错了。 接着往下走，大家看这个漏斗的第二层，精选重排层。这时候我们手里可能还有三五十个段落，如果全塞进去 prompt 还是太长，那怎么选出最核心的那五个？这里就得请出 cross encoder， 也就是重排模型 reinker。 大家一定要理解为什么 rerun 比第一步的剪辑更准。第一步剪辑是点对面，它是把 query 的 向量跟库里成千上万个向量比，为了速度，它牺牲了精度。而 rerun 是 面对面，它把 query 和每一个 chunk 放在一起。深度对比。 这一步，我们可以设置一个动态域值，比如，如果前三个段落的分数特别高，我们可能只要这三个。如果分数都很平庸，我们就多选几个。这个过程就是为了提精度，抓核心，确保留下来的每一句话都有可能包含问题的答案。 好，重点来了，大家看第三层，这是最体现技术深度的地方。提纯一层，很多同学说，既然已经选出最相关的段落了，是不是直接喂给模型 还没完？有些段落虽然相关，但里面废话极多。这时候我们要用到一个核心黑科技，叫做 l l m linggu， 大家听这个名字， linggu 就是 语言的意思，它的底层逻辑非常精妙，它利用一个小模型去算每个 token 的 困惑度 perplexity。 我 给大家解释一下什么叫困惑度。简单说就是一句话里哪些词是可预见的。比如我说不仅什么，而且什么那个，而且就是废话模型，不看它也能猜出来 l l m。 拎瓜会通过 p p l 算法，把那些信息商极低的起修饰作用的废话注词通通剪掉。你要记住，这是一种 token 级的提纯，它能把原本两千字的上下文压缩到三百字，但关键的实体指令和逻辑股价全都在模型读这种压缩后的文本， 就像我们读划了重点的笔记一样，注意力会极度聚焦。讲到这，你可能会问，压缩的这么狠，万一压错了，正确率怎么保住啊？大家看我图里中间这三个蓝色的方块，这三个方案就是你的保命符。 第一个叫应约束保护，我们在做语义压缩的时候，不能完全交给算法，你要在代码里写死所有的日期数字，专有名词，否定词必须百分之百保留。 你想想，如果把合同不与续约压缩成了合同续约，那这个压缩算法就是灾难，所以应约束是保证正确率的底线。第二个叫上下文重组，这块非常有技巧，刚才我们说了模型会中间遗忘，那我们就玩个心眼，把压缩后得分最高的那些信息重新排列， 不要全堆在中间，我们要把最重要的部分放在 prompt 的 最开头和最末尾，这就叫避开黑洞，利用直觉让模型在最清醒的位置看到最关键的数据。 第三个叫 regas 评估闭环，大家做工程一定要有量化意识，你不能拍着胸脯跟老板说我压得好，你要拿数据说话。 ragas 框架会从忠实度、相关性和精度三个维度给你的压缩结果打分，只有形成这个闭环，你才知道你的压缩域值是不是设的太高了还是太低了。最后大家请看屏幕最下方，也就是咱们这张架构图的面试高分总结，话术 这块大家一定要多看两眼，因为这决定了你在面试官眼里的段位。第一点也是最核心的思想，你在面试中绝对不能只谈怎么删减，你要展现出一种系统工程的视野，你要告诉面试官上下文，压缩其实是关于性造比与推理成本之间的权衡艺术， 因为每一条丢弃的信息都是潜在的风险，而留下的每一条信息都是实打实的成本，这种对平衡感的把握才是专家和新手的区别。第二点是关于你的落地思路，你要强调你是通过一个三段式漏斗来实现的。从最外层的粗筛混合剪索， 到中间层的精选 re rank， 再到最核心的提纯 token 级压缩，这一套层层递进的逻辑不仅展现了你的技术储备，更展现了你在处理大规模数据时的层次感。第三点就是咱们刚才反复强调的防坑指南， 一个真正有实战经验的人，一定会主动抛出风险，你要主动跟面试官提中间遗忘和羽翼漂移，然后紧接着给出你的解决方案，通过重组和应约束来规避，这套连招下来，面试官根本找不到破绽。 好了，这张架构图建议大家截图保存在你的项目里，哪怕只用到其中的一部分，你的锐克系统的性能和成本表现都会有一个质的飞跃。
239AI大模型-楼兰
02:59查看AI文稿AI文稿为什么同样是大窗口，代理有的能连跑很久，有的二十分钟就开始绕圈？差别往往不在窗口本身，而在窗口满了以后，系统怎么压这段历史。所以这条视频只讲一件事，为什么压缩器比上下文窗口更重要？ 先把两个问题分开，上下文窗口解决的是这一轮能装多少压缩器，解决的是下一轮还能不能接着干。一个是容量问题，一个是连续性问题， 而容量这个问题，迟早会自己找上门。真实代理回合里， system history、 retrieval tools 和 output 会一起去窗口。窗口从来不是只拿来装聊天记录的， 所以在常任务里，压缩不是锦上添花，而是必经步骤。真正的问题不是要不要压，而是谁来压，以及按什么规则压。 那压缩器到底在做什么？他不是简单删几句聊天，而是在把当前工作现场改写成下一轮还能继续读取的短历史。这一步一旦改错，后面轮次看到的就不再是现场，而是现场的一个失真解释。 压错之后，代理通常不会先忘掉走目标。他先忘的是文件路径、函数、签名、错误码，还有刚刚跑过的测试。所以真正先坏掉的不是任务方向，而是工作现场。 这也是为什么很多代理不是停住，而是开始绕圈。他还记得继续修这个 bug， 却忘了自己刚刚读过什么，改过什么，验证到哪一步。于是下一轮又重新读文件，重新跑测试，重新走。就分支 这件事不是体感，而是能测出来很多压缩方案的 instruction retention 其实不差，真正签掉的往往是 artifact tracking 这类现场状态。 把 retention 和 artifact tracking 放在一起看，结论会非常直观，总目标大多还能记住，但和工作现场直接相关的信息掉分会更明显。 所以评价压缩器别先看它压得多短，先看它能不能把关键状态推理延续性和弓箭轨迹留下来。压缩率只是结果，状态保留才是生产指标。 行业里为什么会出现自我摘药、延后压缩、 handoff 和边界触发这些不同路线？因为大家已经把压缩器当成独立运行时系统，而不是一个顺手加上的摘药功能。 但这里还有一个边界必须分清。压缩器解决的是绘画内连续性，解决不了隔夜多绘画和长期经验沉淀，所以 compaction 和 memory 必须分开设计。 如果你今天做代理，我会先做五件事，先保工作状态，再在任务边界压缩，先清理再压做。贝斯兰对绘画内压缩和长期记忆分层设计， 这些动作通常比继续加大窗口更接近真正的工程结法。所以以后再看一个代理系统，不要先问他窗口有多大，先问他窗口满了以后谁来决定什么能活下来，那个决定才真正定义了这个代理的上限。
12沐晨AI笔记
03:15
07:53查看AI文稿AI文稿大家好，这里是 ai 深度幻觉今天的面试题，如何设计一个高效的 agent 上下文维护方案？这题简单吧，上下文太长就压缩不就完了？ 呵，如果你这么答，面试官心里已经怕死你了。我们之前在 agent 架构包括哪些部分那期讲过， context engineering 只是 agent 架构答案的第四层，这期我们把这一层完全拆开，里面有四象限框架， compress 横屏三阵营记忆系统，还有四层污染防御 等。一下先说清楚，为啥不能简单压缩。 chroma 二零二五年七月做过一个大实验，测了当时最前沿的十八个模型， cloud 四 gpt， 四点一，全系 gemna， 二点五块三，都在内跑了将近二十万次调用。结论很暴力， context 越长，所有模型都会变蠢，没有例外， 必然加个换一下不就行了，只要还是 transformer 是 啥？专门拆过 n 的 平方这条线。 简单说，每个 token 要和所有其他 token 算关系， n 个 token 就是 n 平方个关系。 n 方复杂度意味着 attention budget 被越多 token 瓜分，每个 token 分 到的权重就越薄。这是架构级的数学约束，不是工程 bug。 那就直接买更大的 windows 呗，一 m 二 m 总够了吧。呵，残酷的是，多个长上下文 benchmark 反复显示，实际可靠容量通常远低于宣传值。 m r c r v。 二是二零二六年各家厂商最长拿来做长上下文横屏的硬指标。 anthropic， open ai， google 三家的 system card 都在报这个数。虽然 anthropic 的 cloud code 负责人 boris chaney 在 x 上说他们在慢慢淘汰它。 jammer 三点一 pro 给了一百万在 em 的 pointwise m r c r v 二上只拿到百分之二十六点三， cloud office 四点六。在一百万的八 needle mrcrv 二上， anthropic 官方数字是百分之七十八点三，也就是说，还有超过两成的事实会丢。这还是已公开数据里最高的。更狠的来了，前两天二零二六年四月十六号发布的 opus 四点七， system card 里同一个测试跌到百分之三十二点二， 社区直接把这个叫 regression。 不 管你信哪种说法，简单的架构升级并没让长上下文， recall 自动变好，这反而支撑了我们这期的核心论点。 我猜业界应该早有分类了，不会每加一套吧？ linching 给了业界最权威的四象限框架， write， select， compress， isolate。 二零二六年显示做 context engineering 的 主流 agent 基本都能套进这四个动作。 biterlesson 派是例外，他们主张让模型端到端，自己学， 四个都要做，太累了吧。按直觉， compress 最省钱，是不是先上这个？二零二六年， select 是 性价比最高的一层，我们之前在 m c p vs skills 深聊过 skills 的 三级加载，这里指点一下关键。 anthropoid， 二零二五年十月十六号首发 agent skills， 十二月十八号作为独立 open standard 开源到 agent skills， 点 i o， 每个技能在发现阶段中位数只占八十个， tokens 只是一行名字加描述。 microsoft 的 vs code 和 github open ai cursor 这些几周内都跟进了同一个格式，那 compress 就 没用了， 没这么绝对。 factory 点 ai， 二零二五年十二月做了一次严格的三派压缩对比 accuracy 维度上， factory 自己的结构化招标得四点零四分， anastropic 的 cloud sdk 得三点七四， open ai 的 opaque compact 只有三点四三 啊。 oprah 压缩率百分之九十九点三，但准确率最差。对，这揭示了一个大多数人第一反应会搞反的是优化目标，不是 tokens per request， 是 tokens per task。 压得狠会丢细节， agent 要回头重读重搜，省的 token 全赔回去。 那记忆系统生态有没有决定性的信号？有，最强的信号来自 lata。 这家公司是 mem gpt 论文的商业化，原来主打核心记忆加规当两层的 o s 分 页范式。二零二六年二月十二号，他们发布 context repository， 其中命令叫 mems， 把 memory 充写成了 getback to file system。 至少从外部看方向和 anthropic the progressive disclosure 是 收敛的 等等。那这是不是说 memo gpt 输了？这是研究者的强解读。雷塔自己的措辞是 rebuild 和 evolution 不是 放弃， 但一家以 memo gpt 为核心的公司，产品迭代跑到 file system 范式上，这本身就很说明问题。开源记忆生态二零二六年分成三阵营， file system pie， graph pie， 还有让模型自己学的 biter lesson pie， graph pie 是 做什么的？ zipp 做的。 grafiti 特别值得一讲，每个事实待四个时间戳 created at valid at， invalid at expired at。 事实被修正时不删除指标 invalid at， 并见因果边。 open ai 二零二五年中的官方 cookbook temporal agent 模板，明确借鉴了 grafity 的 prompt a patch 二点零 adapted。 这个设计好巧妙，那上下文污染怎么处理？就是代码变了，信息被修正了， agent context 里的旧数据怎么办？ 这是个真正难的问题。业界两千零二十六的答案是，没有银弹，必须四层同时放数据。结构层用 memeline 的 update delete 或 grappled 的 by temporal， contract 层用 claud called read before edit。 硬约束 版本化层用 let context repository 的 get commit。 最后是心理，模型层接受 stillness 会发声。宁可过度 reread 啊，宁可过度锐锐的，这不浪费吗？有数据支撑，有人追踪过一百三十二个 cloud code session， 发现百分之七十一的文件 read 是 庸俗的。 agent 宁愿多读也不信旧版本。社区预测，这可能是 anthropic 有 益的设计取向。 style context 的 代价远高于过度验证的代价，这些都是工程手段。模型层面有没有什么新动作？ 除了 recode 这条线。四点七，同一次 g a 发布里还带了一个叫 task budgets 的 源语。模型本身是正式版，但 task budgets 作为 public beta 特性跟着一起开放。 beta header 是 task budgets。 二零二六零三一三机制使模型直接看到运行中的 token， 预算倒计时，主动按预算优先级排序工作并优雅收尾。 task budgets 不 动架构层的 n 的 平方， 它是调度层在给定的注意力约束内，让模型自己做取舍。简单说， n 的 平方没解， recoil 还是会跌，但在给定的 n 的 平方约束下，把预算管理从外部强制培训交给了模型内建。属于调度层的增量优化，不是 recoil 问题的解法。 面试时怎么答才能加分？三十秒电梯答上下文维护的本质是用有限的 attention budget 维持常识任务的 coherence， 工程上按 linchang 的 四象限选型， select 最便宜 write d 二 compress 是 保底， isolated 最谨慎。这是综合业界实践的排序，不是 linchang 框架自带的，没有银弹，四层防御并用。面试想拿高分。 t agent skills， the progressive disclosure ladder， context repository graffiti by temporal 还有 opus 四点七 task budgets 这四个两千零二十六专属型号。最后一句话总结，这期 四象限 compress 横屏三正盈四层防御。这一层拆完，你会发现 context 的 维护不会因为 window 变淡而消失， 它从能不能塞下的容量问题变成了塞什么进去最好的认知问题。这和人类工作记忆的本质约束一样，是认知层面的限制。有啥想拆解的面试题评论区留言告诉我，觉得有帮助的话一键三连，我们下期再见！
02:34查看AI文稿AI文稿你有没有发现，用 cloud code 写代码聊半小时， a a i 就 开始胡说八道了？一次 playwrite 快 照五十六 kb， 二十条 issues 五十九 kb， 四十分钟上下文就满了。 agent 开始压缩对话，然后忘了你在编辑什么任务，做到哪了。一个叫 context mode 的 开源项目，把上下文压缩了百分之九十八， 九千多 star 今天还在涨，你让 ai 搜个函数三百多行，结果全塞进去，读个文件一千八百行，跑个构建两千三百项日制，这些都吃你的 token。 没有 hook 的 时候，模型只有百分之六十的概率遵守指令，它随时可能跑一个 curl 把你的上下文称爆，一次失控，整轮节省就白费了。原理分两层， 第一层是沙箱过滤所有工具输出，先进沙箱自动提取关键信息，压缩溶于结构化输出三百一十五 kb 变成五点四 kb， 通过 m c p 和 h o k 适配各个平台。第二层是绘画恢复 sq lite 加 f t s 五加 b m 二十五全书剪索，把每次工具调用文件编辑 get 操作全部记录下来。上下文压缩前自动构建一个不超过两 kb 的 优先级快照， 压缩后通过 session guide 十五个类别恢复工作状态。模型继续从你上次问的地方开始，不会失忆，直接看数据。 playwrite 快 照从五十六 kb 压缩到二百九十九字节，二十条 github issues 从五十九 kb 变成一点一 kb， 访问日制从四十五 kb 直接压到一百五十五字节， 加起来三百一十五 a b 变成五点四 kb。 绘画时长从三十分钟延长到三个小时，六个核心 m c p 工具，二十一个 benchmark 场景全部验证，跟其他方案比一比。 cloud code 自带的 compact 只是截断不恢复状态。 ockment code 币源榜 ide envelope 官方建议用 sub agent 架构，绕过限制，但增加系统复杂度。 context mode 不 改变你的 agent 架构，从工具输出端拦截压缩，加上 sq lite 绘画恢复，双保险开源 elf 二协议，六个平台通用，纯 npm， 零依赖传统 agent 压缩对话后忘了文件，忘了任务，忘了你说了什么。 context mode 的 绘画连续性解决了这个问题，每次工具调用都被记录到 sq lite 压缩前自动构建一个不超过两 kb 的 优先级分层快照压缩后通过 session guide 十五个类别恢复文件编辑， get 操作任务状态，用户决策全都在模型。继续从你上次问的地方开始给你的 ai 助手减负吧， 他不是变笨了，是被垃圾数据喂称了。三百一十五 kb 压缩到五点四 kb， 绘画从三十分钟延长到三小时。六个平台通用，百分之九十八压缩率一行 m p m install 搞定，或者直接 m p x 运行去 get help zone case school 斜杠 context mode， 试试你的 ai 是 不是变聪明了。
10:39查看AI文稿AI文稿今天我们想跟大家聊一聊，在做长上下文的这个 agent 的 时候，为什么 catching 是 不可或缺的，以及 prompt catching 到底在整个架构里面起到一个什么样的作用。 ok， 没错， 这个也是最近在行业里面非常非常火的一个话题，那我们就直接开始吧。咱们首先要聊的主题啊，就是缓存机制与结构 啊，就是这个 prompt catching 到底是怎么工作的，对吧？它的底层的这个逻辑是什么？其实 prompt catching 它就是会把你输入的 token 序列的中间状态给你缓存下来，然后它的这个匹配呢，是通过精确的哈希匹配，也就是说只有当你的这个 token 序列 从第一个到你指定的那个断点全部都一样，他才会认为这两个是同一个缓存。所以就是说哪怕我就改了最前面的一个 token， 后面都不变，那也得全部重新算呗。对，就是这个意思，所以就说，呃，你在使用这个 prompt catching 的 时候， 你这个 tos 或者说 system messages 这些东西的顺序是非常重要的，而且你最好是把那些最稳定的东西放在最前面， 这样的话可以最大程度的去提高你的这个缓存的使用率。那就是说这个 cloud code 它到底是怎么把这个提示分层的，然后又怎么用到这个缓存里的？它是一个三层的缓存结构，嗯， 最下面的一层呢，是放的是局都不会怎么变的一些系统的提示和工具的定义，这个是大家都共享的。再往上一层呢，是每个项目自己独有的一些配置， 最上面一层是每个对话自己的一些动态的历史，嗯，然后每一层呢都只会缓存自己关心的那一部分内容， 这样的话就可以避免很多不必要的重复计算。那这个分层之后怎么保证说我每次都能精准的命中我想要的那个缓存呢？这就要靠 catch control 这个标签了。嗯，你可以用它来做一个断点， 然后它会自动地帮你检查说你这个最长的匹配的前缀是哪个，你可以去指定最多四个断点嘛，那它就会从最长的那个匹配的地方开始给你读缓存， 这样的话就可以保证你这个每一个部分的这个更新都不会影响到其他的部分，最大限度地去利用了这个缓存，又保证了这个灵活性和隔离性。哦，我明白了。那在实际应用这个 prompt catching 的 时候，有哪些比较容易被大家忽略的一些最佳实践，或者说一些小陷阱呢？ 比如说像这个把动态的内容，比如说时间戳，或者说一些变化很频繁的一些参数放在了这个很容易被缓存的这个部分，就会导致你这个缓存几乎是无效的。 就是你要把这些东西单独拎出来，不要让它污染了你的这个稳定的前缀。就是说这个顺序和这个内容的稳定性其实是非常关键的。对，然后包括像这个系统的提示，尽量不要去动态的修改它。 那如果说你真的需要传递一些变化的信息的话，你可以通过这个 messages 这个参数来传递，这样的话就能更精准地去命中缓存。没错没错。然后还有就是比如说像这个工具的这个定义的顺序啊，一定要保持一致，包括你这个如果是团队协助的话，一定要把这个公共的配置啊都统一好。 还有就是要监控这个缓存的命中率啊，包括你再做一些，比如说像对话的压缩呀，或者是说这个绘画的这个 branching 啊，就是你要特别小心，不要破坏了这个原有的这个前缀。好的，那我们接下来就进入一个非常实用的一个环节啊，就是操作的要点和陷阱。 呃，就是说这个在实际使用 catching 的 时候有哪些常见的误区和对应的最佳实践？最常见的一个误区就是你会在运行的过程当中去修改这个 system prompt， 对， 那这个就会导致你的这个缓存全部都失效。 那你正确的做法其实是把你想要的这个动态的信息放到 user message 或者是说这个 two results 里面去传递， 那这样的话就不会影响你的这个缓存的前缀。哦，原来是这个传递的方式，也会影响到这个缓存的命中率，对，没错，没错，对。然后还有一个就是说你这个工具的这个增减，或者说这个换顺序，其实也是会导致你的这个缓存失效的， 那你可以用一个就是统一的这个工具的列表里面有一些就是标记位来控制他的这个状态。那还有就是说这个模型的切换也会导致你的这个缓存失效， 那你可以用这个子智能体来做这个分叉的这个处理，就可以避免这个问题，就是让每一个这个叫什么对话的路径，它都是可以独立的去缓存的。嗯，明白了，那这个在做这个长上下文的这个 catching 的 时候，这个上下文的压缩有哪些关键的细节需要注意呢？ 就是你在压缩的时候，你一定要保证你的这个系统的提示和你的这个工具的定义是跟你原来的那个绘画是一模一样的。 然后你通过一个特殊的这个压缩的消息类型来进行一个标识，这样的话他才能够正确的去命中这个缓存。 你也可以通过这个只留最近的几个工具的结果，或者说你把这个大的输出持久化到外部，在本地维护一个压缩的状态，来帮你做这个更精细的控制。听起来好像这个压缩的这个策略的设计还是挺有讲究的，没错没错，对不对？对， 因为如果你这个策略做的不好的话，就很容易出现这种摘要丢失关键信息啊，或者说这个模型的性能下降啊，或者说这个缓存命中率低啊等等的问题。 那你可以通过主动的触发压缩呀，然后给这个压缩加上一些自定义的描述啊，用这个紧凑的消息结构啊，包括去监控这个缓存的命中率啊等等的一些手段，来提升你的这个整体的效率和稳定性。 ok， 我 们再来讲一下工程化落地的建议，就说我们在做这个实际的工程化落地的时候，在使用 prompt caching 这个技术的时候，有哪些比较实用的建议可以帮我们去避免一些常见的坑呢？最核心的就是要把你的这个 system prompt 和你的这个工具的定义放在最前面， 而且保证它们是不会变的，然后把你的这个动态的信息都放到这个 messages 里面，并且通过这个 catch control 这个断点来做一些分层的处理。你要去监控你的这个缓存的命中率，如果这个命中率有异常的波动的话，往往就意味着你的这个 缓存的结构，或者说你的这个流程上面出现了一些问题，那你就要去调整你的这个策略，所以说这个结构设计和这个监控都是缺一不可的，而且就是要尽量的去避免在这个中间去更换你的这个模型，或者说更换你的这个工具级，然后要合理的使用这个 子智能体和这个压缩的机制啊，那你这个系统才会比较高效，比较稳定。如果你违反了这些原则的话，比如说你随意的去改变了你的这个前缀啊， 或者说你这个压缩的时候丢失了一些关键的状态啊，都有可能导致你的这个缓存彻底失效，那你的这个系统的开销就会暴增， 所以说这些细节都是非常重要的。说得很有道理，那我们就来进入今天的这个设计原则的总结，那这部分就想请你分享一下，你认为在做这个 prompt catching 的 架构设计的时候，最需要关注的一些核心的要点就是你要让这个 catching 真正的高效， 就是你首先第一点就是你要把你的这个 system 的 部分和这个 tool 的 定义都作为一个只读的前缀， ok， 对， 然后这个东西一定是大家共享的，不变的动态的内容一定是放到后面，而且你最好是通过一些 catch control 这个断点啊，把它分层， 这样的话可以最大化的去复用。所以结构的分层和这个内容的隔离其实是很重要的，那就是说这个缓存的键的设计和这个更新的机制也是非常有讲究的，对吧？对，就是缓存的这个键， 你要能够去精准的区分不同的用户，不同的绘画，包括你要去有一些敏感的信息，你要能够去识别出来，不要放到这个共享的缓存里面， 你的这个缓存的更新，你要能够去支持这种版本化的管理和这种主动的失效，甚至你可能需要有一些这种多级的缓存和这个羽翼的解锁，你才能够去扛住这种高病发。你的这个监控一定是要覆盖到这个命中率啊， 延迟啊，包括这个存储的使用啊等等这些关键的指标，你才能够真正的让这个架构是安全的，是高效的。说的很详细啊，那我们就想请你聊一聊，在你看来，要想做好这个 prompt cashing 的 这个状态管理和这个更新的机制，哪些原则是最核心的？ 就是我觉得要让这个 catching 真正的有效，你最核心的就是要把你的这个 system 和这个 tool 的 这个定义作为一个只读的头部，然后永远都不要去动态地修改它，所有的变化的部分都应该通过 user message 或者是 tool result 这种方式来进行一个追加， 这样的话你才能够保证这个缓存的这个前缀它是稳定的，可以被附用到的。哦，原来是要彻底的隔离这个静态和动态的内容，对，而且就是这个缓存的更新，你要能够去支持这种版本化的管理和这种主动的失效， 对，就是你可以通过比如说这个模型的版本，或者是这个工具的版本作为这个缓存的键的一部分，然后配合上这种事件驱动的这种机制，可以去批量的清除， 或者是说你可以定期的去扫描，加上这种 t t l， 你 可以去设置不同的这个缓存的时间。对于不同的内容，包括你可能需要有一些这种对于敏感信息的一些特殊的处理，就是你要能够保证这个数据的安全性和这个时效性是同时都可以做到的。 好的，那我们最后一个话题就是在实际生产环境当中，要想做好这个 prompt caching 的 监控和评估，有哪些关键的指标是我们必须要关注的？首先最核心的就是你要去追踪这个缓存的命中率， 这个是你要去追踪的一个核心的指标。然后这个命中率我们一般的话是要保证在百分之六十以上，如果是那种特别特别高病发的场景的话，可能要到百分之九十以上你才算是 ok 的。 哦。那除了命中率之外，还有哪些指标是我们必须要关注的？ 还要看这个平均的缓存的延迟，这个一般的话我们是要控制在五毫秒以内，你才能够保证说你的这个整体的性能是没有被拖累的。哦，原来还需要关注这个存储的使用情况，对，当然啊，就是你这个存储的用量不能超过这个系统的这个上限， 比如说你的内存，或者说你的这个 register 的 这个实力，它的这个上限，然后配合上一些这种告警的规则，比如说你的命中率下降了， 或者说你的这个延迟突然之间飙升了，或者说你的这个存储的用量快要满了等等的一些情况，你可以去及时的发现说， ok， 我 这个系统是不是出现了一些问题？对了，还有个问题就是怎么去评估这个缓存带来的实际的收益呢？你可以去做一些这种缓存的预热， 就是在上线之前把一些热门的内容提前加载进去，你可以去做一些这种 a b 测试对比，有缓存和无缓存的效果， 最终你可以去准确地评估说， ok， 我 这个缓存到底给我带来了多少的收益？今天我们把这个缓存的这个架构的设计的一些细节和一些最佳实践都给大家聊了一遍，嗯，对， 然后也希望能够激发大家去尝试着在自己的这个 agent 当中去应用这些思路。嗯，对。好了，这就是本期节目了，感谢大家的收听，咱们下期再见，拜拜。拜拜。
112大厂吾师兄（AI篇）
07:04查看AI文稿AI文稿介绍一个改变 ai 编程助手工作方式的新工具， graphify。 在 日常开发中，我们常遇到一个问题， 当把整个项目喂给 ai 时，他每次回答都要重新读取几万甚至十几万行代码。这不仅消耗大量 token， 响应慢， 而且 ai 很 容易在大量文件中迷失方向。 graphify 的 出现就是为了解决这个痛点，它能把任意文件加一次性翻译成可查询的知识图谱。之后 ai 每次查询只需读取图谱结构，无需再碰原始文件。 官方称可实现七十倍以上的 toc 压缩。 graphify 本质上是一个 c l i 工具与 agent skill 的 组合体，你只需要在终端执行 p i p 这一行命令， 然后用 cf 发音哨注册，它就会自动注入一份 skill 点 m d 到你的 ai 编程助手中，助手会明确知道何时如何调用图谱。它的亮点非常直接。第一，七十一倍 token 压缩。 原来 ai 回答一个问题要读十万字，现在只需一千四百字，省钱更省时。第二，支持多模态输入代码， pdf 截图、录音全部能处理并混入同一张图谱。 第三，改了代码自动更新，无需手动重跑，图谱会实时同步项目变化。第四，完全本的运行，零数据库，依赖数据隐私，绝对安全。图谱是怎么生成的？ graphify 采用了确定性加概率性双轨策略，在源码 extract 文件下， 确定性路径依赖 chasis 进行静态 a s t 解析，精准提取函数类调用关系，概率性路径则由 l l m 并行提取语义处理文档、决策逻辑等非结构化信息， 整个流水线非常清晰。首先， detect 识别文件类型应 just 排队入库。接着进行跨文件解析，用 build 整合成图。随后 cluster 执行卢维社群检测自动化分代码模块 analyze 负责架构关系计算， report 生成 markdown 报告。 最后 export 交付可用图谱。音频文件会有本地的 whisper 模型转录，视觉内容则调用多模态识别能力， 所有数据最终统一入图。我们看一下实测，让 cloud code 用 graphify 给我们的 graph memory 文件生成知识图谱。第一步，确保 graphify 已安装。第二步，检测结果发现文件数量和词数在域值内， 直接进行提取，无视频文件跳过。第三步，提取实体和关系五个文件需要羽翼提取，枪可以已已写入完成羽翼合并， pad c 合并 a s t 加羽翼，结果一百六十七，节点五百六十一边。第四步，构建图具类分析。 第五步，读取社区节点，命名社区标签，生成 html 格式化返回处理结果。当我们运行完 graph file， graph report 点 m d， 这是最重要的知识摘要，里面汇总了项目的架构全貌，核心节点关系以及关键业务决策。当你问 cologeco 的 这个项目怎么回事时，它读的就是这份文件。 graphd html， 这是图谱格式化看板，它是网页格式，你双击在浏览器里打开， 就能看到你的代码库变成了一张网状的互动地图。它是用来帮你直观感受项目结构的，这就是我们记忆项目的 index 文件，我们可以详细查看它们之间的关系。 garp 点 jason 图谱的原始数据源，它存储了完整的图结构信息，如果你想自己写脚本去查询这个图谱，或者把数据导进数据库，就读它。 catch 文件夹，这是增量翻译的核心，里面存着上一次扫描的结果。 graphify 通过对比这里的数据，保证你下次运行只需处理变动过的代码，极大节省了时间。 cost jason， 这是账单记录， 它记录了你这次翻译过程中调用 l， l m 进行语义提取，消耗了多少资源或 token。 这对于企业及用户或需要精细控制成本的开发者非常有用。 manifest 点 jason 图谱配置清单，它记录了这次变异任务的原数据，比如处理了多少文件变异的时间戳，以及使用的是哪种配置模式。它是系统校验图谱是否版本最新的凭证，生成的图谱，不是黑盒。 gufeifei 内置了严格的信信度分级，明确定义的源码关系，标记为 infotain， 属于合理推论，无法完全确定的连接标记为 ambiguous， 会高亮提示人工审核底层结构，采用标准的 nodus 加 e g s 股价，并由 validate p y 进行完整性校验，确保图谱逻辑闭环。在一个多月前，我们开源的 graph memory 也是通过知识图谱优化 a 键的记忆 对比，两者整合工作流本质不同。 graphify 处理的是项目文件，构建的是代码的确定性逻辑， 解决的是局视野受限和勇于偷坑问题。而 graph memory 处理的是对话历史与决策日制，它解决的是记忆断层和个性化缺失， 维护的是你们聊过什么，踩过什么坑。 graph file 数据源代码多模态输入 graph memory 的 数据源是对话、历史、用户偏好以及决策日制 graph file 构建方式，静态扫描加自动监听更新。 graph memory 是 动态追踪加 ai 摘要提炼 graphify 的 技术栈是 a s t 加图谱格式化。 graph memory 是 向量数据加知识图谱。 graphify 在 cloud code 等助手中直接定位模块调用链与数据流。比如这个项目的支付模块是怎么工作的，使用 graph memory 使用时遇到相似的 bug 时， ai 主动调取历史决策与排错记录，比如上次装的那个库的报错是怎么解的？讲到这里，大家可能会好奇，如果项目规模再大一点，代码库演变成数百万级的知识图谱，目前的解锁技术还能扛得住吗？ 最近推特上有一篇非常硬核的深度长文，系统性的梳理了大规模图数据的高效查询范式。作者总结的这套理论，恰恰是工业级知识图谱能够实现毫秒级响应的关键。它揭示了在面对海量数据时，我们应该采取的四种优化策略，第一，建立分类所引， 通过预设标签直接定位，决不全量便利。第二，选择性优先。多条件搜索时，先执行过滤结果最少的条件，最大限度削减后续数据量。第三，双向搜索 路径查找，从起点和终点同时向中间推进，实时比对交汇点，大幅缩短耗时。第四，缓存与雾化，高频查询结果预计算并持久化，后续直接读取，跳过重复计算。 graphify 这个工具在目前的实现中， 虽然还不涉及分布式集群查询，但已经引入了这套思想的先行版。比如它通过看似 d i p y 实现了数据的部分物化，通过文件类型的分类识别实现了初步的缩影过滤。 graphify 让 ai 从盲目读文件进化到结构化读图谱配合 graph memory 的 记忆能力。你的编程助手将真正具备大局视野与历史经验我们的编程助手将真正具备大局视野与历史经验。我们的编程助手将三连获取。点个免费的私大吧，感谢观看，我们下期见！
2939AGI_Ananas
06:51查看AI文稿AI文稿今天给大家介绍几个在 skill 设计里面节约上下文的实用的技巧。那我自己做 skill 的 时候，一直坚持一个原则，就是能在上下文外面干的活，就不要搬到上下文的里面来。 智能体的工作台啊，它的空间是有限的，每一次读取文件，调用工具，生成回复，它都会往工作台上去堆东西，那当工作台被塞满，智能体就没有办法继续工作，只能中断任务，或者是丢弃部分的信息。也就是很多的 ai 工具会显示的上下文压缩， 一旦压缩，很多信息呢，就丢掉了，那你感受到的就是 ai 的 降智。那最常见的情况是呢， skill 需要处理大量的文件， 如果他老老实实的把每一个文件都读进来，那么上下文几轮就爆了。比如说你让 ai 分 析一个文件夹里的五十份的报告，他每读一份呢，就会占用几千字的上下文空间，还没分析到第十份啊，工作台可能就满了。那最直接的节约方式就是不让 ai 去直接读文件。 举个例子啊，比如说你做一个 excel 的 一个数据分析的 skill， 那 用户给了一个包括十万行销售季度的表格， 如果让智能体调用工具把表格内容读出来，那光这一步就能把整个上下文撑爆。但实际上呢，智能体需要的并不是十万行的原始数据，而是数据分析的结论。比如说上个月的总销售额是三百二十万，同比增长百分之十二，退货率呢，是百分之三点二这样子的东西。 那解决方法呢？很简单，就是让 ai 呢写一个脚本，让这个脚本在上下文之外完成数据的处理，只把结果输出到这个智能体里面。 那比如说啊，在一个数据分析的 skill 里面，那你可以让 ai 帮你去生成一个脚本，来自动地读取你的 excel 的 数据，并且输出汇总的结果。这个脚本在后台呢，读取十万行的数据，计算各种指标，最后呢只输出几行汇总的数据。智能体拿到的是精简之后的结论，而不是原始的数据， 上下文几乎没有额外的消耗。那同样思路呢，也适用于很多场景，比如说分析日制文件的时候，你可以用脚本来统计错误的类型，还有频次，并且筛选出出错的那几行，而不是让智能体来读取整个日制。凡是数据量比较大，但是结论比较简短的环节，你都可以交给脚本。 但是上面的方法呢，其实有一个前提，那就是脚本做的是纯计算，有些任务呢，可能需要 ai 的 理解和判断能力。比如说啊，你想去做一个批量处理一千份简历的这个 skill， 阅读一个简历，并且提取关键的信息。普通的脚本呢，是做不了这种事的，必须要用到大模型才行。那怎么办？答案呢，就是让脚本去调用另外一个 ai 大 模型来帮忙。这个听起来有点绕啊，但是我给大家做了一张图，大家也可以看一下。那 这里的关键是在于理解，在这个流程里面，有两个 ai 在 工作，各自呢扮演的是不同的角色。一个 ai 呢，就是你直接用的那个 ai， 比如说啊，这个 cloud code 啊， open code， 小 龙虾，或者各种国产的智能体， 你向这个智能体呢去提出一个任务，比如说帮我把这五十份儿的文档各写段儿摘要，那智能体呢，会读取你的 skill， 那 这个时候呢，你只需要在 skill 里面写句话，说对每个文件运行 summarize file 点 p y 这个脚本。于是呢，智能体它就不会自己去读这五十份儿的文档，它会自己去执行你说的这个脚本， 那这个脚本里面会干什么呢？它呢会打开这个文档，然后读取里面的内容，然后呢，再独立地调用一个 ai 大 模型，把文档的内容给发送过去，而它是一个独立的 ai， 这不是当前正在工作的那个智能体。 ai 呢，会请求那个独立的 ai 去生成招标。啊，听起来有点绕，对不对？那个独立的 ai 大 模型处理完之后呢，把这个招标的结果再返回给脚本，然后脚本呢，再把结果保存到一个输出的文件里面。五十个文件都处理完之后呢，智能体只需要读取五十份的精简之后的招标文件，就可以继续后续的工作了。 那这里的关键之处啊，就在于，智能体自己没有去读那五十份的原样的文档，它呢只是去指挥脚本干活，而这个脚本 它调用的是那个 ai 大 模型。但那个 ai 大 模型呢，跟这个当前的那个智能体的大模型，它的上下文是完全隔离的，它有自己的独立的这个智能体的空间，也就是说，无论的五十份的这个文档有多长，它都不会占用智能体的上下文。最终呢，进入到这个智能体上下文呢，只有五十份短短的战略， 那脚本是怎么样调用另外一个 ai 大 模型的呢？我们平时使用 ai 的 时候，都会打开网页或者 app 跟它聊天，那脚本又没有手，那怎么跟 ai 对 话呢？其实几乎所有的主流的大模型，比如说 dbic， 七 m， clock 和叉的 gpt， 它们除了提供网页和 app 的 聊天界面之外，它们都提供了一种叫做 api 接口的东西。 那 api 呢，就是程序和程序之间沟通的一个通道，那在这样的一个场景里面，脚本通过 api 向大模型发送段文字，而大模型处理完之后，会通过同一个通道把这个结果返回回去。整个过程呢，你不需要打开任何的网页，全部可以在后台自动完成， 你可以把它理解成网页和 app 聊天，是你亲自去柜台去办理业务。而 api 呢，就是你寄了一封信过去，那对方处理完再把这个信给你寄回来，效果是完全一样的，只是方式不一样。 当然呢，这种方式其实会有点代价，就是脚本每一次通过 ai 去调用大模型都会产生费用，但是跟智能体因为这个上下文爆满而中断任务前功尽弃相比呢，这一点呢，额外的成本通常是值得的。而且呢，脚本里面呢，你可以去选择调用更便宜的模型，这样就可以更进一步的去控制成本。 那你可能会问啊，这种脚本我也不会写啊，答案很简单，就是让 ai 帮你写。那下面我给你一个通用的提示层的模板，你直接复制过去，填入你的信息就能用。而这个脚本呢，它可以封装成一个通用的 skill 给其他的 skill 去用，这样就不需要重复造轮子了。 那我在 ai 成长圈里呢，我也分享了一个写好的 ai 调用的 skill， 如果你懒得自己去做，也可以拿着直接去用，那除了用脚本来节约上下文之外，其实还有一种方式值得了解，就是子智能替 有一些智能体平台呢，是支持把一个任务呢拆分到一个独立的子智能体里面去执行的。子智能体它是有自己的上下文空间的，执行完毕之后呢，就会把最终的结果返回给主智能体，那中间的这个所有过程的所有的数据都不会进入到主上下文里面去。 那这个机制呢，它就天然适合处理各种大量中间计算，但是结果很简短的任务，你比如说让子智能体去阅读，去逐行分析，去产生大量的中间过程， 但是最终返回出来的这个结果可能就是一个几百字的审查报告，那这些中间信息全部都会留在子智能体里面，他不会去污染主对话的上下文。 但是你要注意的就是子智能体平台现在并非所有的平台都支持，而是更适合一些可以独立完成的子任务。如果说一个任务需要频繁的跟用户交互，或者是跟对话的上下文保持同步，那么子智能体可能就没有那么的合适。 好了，说那么多，其实核心的原则就一条，就是把重活脏活给到上下文之外去做，只把干净的结果给搬进来。那么以上内容呢？来自我的 ai 成长圈，五月三号的日课，想成为 ai 超级个体的朋友，别忘了加入。好了，我是 c 哥，如果觉得对你有帮助，别忘了点个赞，这对我非常重要，咱们下期见。
56C哥聊科技
08:01查看AI文稿AI文稿招聘一个顶级程序员 cloud code， 用七天的时间，从基础入门到熟悉精通，把它一步一步打造成你的超级员工。上一期视频呢，我们学会了 ai coding 的 工作方法， 今天你让他开发一个复杂的新功能，一开始很顺利，聊着聊着，你发现它开始降智了， 聊过的信息转头就忘了，因为上下文快满了，之前的记忆被压缩或者丢失了。今天我们就解决这个问题，管理 cloud 的 工作记忆，让它始终保持在一个高效的状态。 那视频呢？最后还有几个我私藏的上下文管理小技巧。 cloud 是 最早提出来 context 这个概念的，让 agent 从 prompt engineering 到 context engineering。 那 到底什么是上下文呢？ 简单的来说，上下门就是 cloud 的 工作记忆，就像是人类的大脑，你这一天你需要记住自己今天早上吃了什么， 今天的工作计划是什么，我正在做的任务是什么？以及一些临时的文件。我刚才看了十个文件，分别是什么，以及在过去的六个小时，我都跟谁开了会，讨论了什么问题。信息量这么大，你肯定记不住所有的细节，于是你就拿了一个小本本，把这些都记下来。 但是这个本子的容量也不是无限的，他就只有十页纸。当这十页纸都用完了，你要接触新的东西的时候，怎么办呢？可能就会随机撕掉某几页，或者是把某几页压缩成一页，给你腾出空间，这就是上下纹衰退。 cloud 的 上下文窗口也是完全一样的。那上下文具体包含什么呢？主要是由四部分组成，第一部分是 cloud 点 m d 就是 系统指令，它包含你的基础站的约定，编码的风格，是 cloud 的 长期记忆， 每次对话都会加载，它是不可压缩的。如果你的 cloud 点 m d 很 长，就会非常消耗头衔，那怎么写 cloud 点 m d？ 可以 看我的 day one 视频。 第二部分是对话历史，就是你跟 cloud 来回的一些讨论，聊的时间越长，上下文占用的就越多。 第三部分也是占用最多的是工具调用的记录，包含你读取的文件内容、运行的命令结果、搜索的代码片段等等，是上下文快速增长的主要原因。 比如你改 bug 期间反复多次的扫描代码，那上下文就会急速膨胀。第四部分是临时的数据，包括你正在编辑的一些文件调试的信息。 cloud 的 窗口通常是二十万头克，大概是十五万个英文单词。当这四部分加起来接近限制，就会出现上下文衰退的问题。上下文衰退会有什么影响呢？当你的上下文充足的时候， cloud 反应会非常迅速，非常准确。 当上下文快满了的时候，那他可能就要搜索半天，记忆会模糊，反应就会变慢，或者改 bug， 改半天也改不对。当上下文爆满的时候，降脂感就会非常明显，甚至会出现失忆，忘记之前聊的重要信息。 同样的问题，上下文不同，效率差别就会非常大。那重点来了，上下文的影响这么大，我们要怎么管理好它呢？ cloud code 提供了很多跟上下文相关的命令，行，我们一个一个来看。第一个命令是 context， 要管理好上下文，首先你就得了解它的使用情况，运行 context 命令，你就可以看到上下文的使用情况，分类占比的比例。第二个命令呢，是 compact 压缩对话， 它适合的场景是你的上下文使用量过高，或者是工具调的结构过高。那就可以用 compact 命令对上下文进行压缩，这样既可以保留关键信息，删除了一部分不需要的细节。第三个命令是 clear 重启， 它的作用是清空所有的对话历史，从头开始。上下文呢，只保留 cloud 点 m d。 那 什么时候用这个命令呢？它比较适合的场景，一个是做任务切换，比如说你上午做用户管理，下午做支付功能，那就可以用 clear 清空清空上午的记忆。 另外一个场景是对话跑偏了，你跟他跑讨论了半天跟主线开发无关的内容，也可以使用 clear 重新开始。 第三个场景是做了一些实验性的工作，你尝试了很多的方案，这样会记忆特别混乱，那也可以使用 clear 整理思路。四个命令是 btw， 这个是二零二六年三月新增的一个功能，专门用来问一些临时性的问题，用完即走。比如说你刚才说的数据表有哪些字段，你现在用什么模型在写代码，你刚才提到的某个记住术语是啥意思， 这种快速的实时查询或者是解释型的问题，就可以使用 btw， 它的特点是不进入对话历史， 问题和答案都是临时的，看完就消失，也不占用主对话的上下文空间。主对话的上下文占用零透肯，他也没有工具的使用权限，不能读文件，不能运行命令，只能基于对话上下文进行回答， 而且可以并行使用。在 cloud 工作期间，你也可以提问，互不干扰，既节省上下文，又不打断工作流。第五个命令是 resume 恢复对话。 你昨天开发了一个新的功能，干了一半，今天想接着干怎么办呢？ cloud code 会自动保存，每次对话到本地使用 resume 命令，就会出现一个近期的 对话的选择器，选择你想要恢复的对话，就可以完整的恢复上下文了。那平时的使用过程中，我们要怎么管理优化上下文呢？送上八个我自己私藏的小技巧。 第一是要定期检查，在密集开发的时候，每两个小时或者每完成一个功能，就要查询一下 contacts 的 使用情况，超过百分之七十就压缩，不要等到 cloud 反应慢了，降至了再压缩。第二个是体温要具体。 cloud 的 查询是通过政策匹配进行搜索的，模糊搜索可能要搜二十个文件，精准搜索可能搜两到三个就可以了。 引用文件多用艾特文件名，指定文件，比描述哪个哪个文件效率要高很多，尽量减少 cloud 的 猜测和搜索的开销。第三个如果有多个改动，合并成一条消息发送，不要一条一条的发， 解释型的问题，临时性的问题多用 btw 的 命令。第五是调试之后要及时清理 bug。 调试的过程中特别容易产生大量大量的代码差错和日制输出 bug 调试之后要及时的 compact， 不要把噪声留给下一个阶段。 第六是长期记忆要写入 cloud 点 md， cloud 点 md 呢？建议分层管理项目的根目录放一些全局的规范子目录放 模块级的说明， cloud 会按目录层自自动读取，力度会更准确，避免每次都加载全部的内容。 第七是可以使用 sub agent 处理探索一些方向的探索，或者不依赖主流上下文的任务，比如说代码审查，就可以交给 sub agent 进行探索，会节约主 agent 的 上下文，这个后面我们会再详细的讲。 第八是善用 checkpoint 做阶段性的总结，在完成一个比较大的功能之后，可以让 cloud 输出一段当前的状态。摘要，你已经完成了什么，遗留了什么，下一步的计划是什么。然后你把这段内容保存起来， 下一次开始对话开始的时候就可以作为第一条消息贴入，等于手动的接上了上下文，比依赖 cloud 的 自己的记忆更靠谱。 那今天我们通过主动的管理上下文，让 cloud 始终处于一个最佳的状态，你已经能非常熟练高效地使用 cloud 了。 但是真正想要发挥 cloud code 的 价值，就不得不提到 scale 和 m c p 了。那接下来就是入职第四天， scale 把专业的知识封装成可以服用的技能包。
86AI产品千媚
02:16查看AI文稿AI文稿大家好，我是大叔，只说真话，只做实在事，只给干货。各位好，今天分享一个 opencloud 的 功能， context engine 智能上下文管理器。说实话，我每天都在用，用了几个月了，真心好用，必须分享给你们。 你们有没有遇到过，跟 ai 聊得正嗨，突然他就二失忆了，前面说的全忘了，为啥呢？对话太长了， tiktok 超限消息被截断，上下文没了， ai 直接蒙圈。 更坑的是，就算用压缩，传统压缩太糙了，关键细节丢光了， ai 抓不住重点回答开始跑偏，你得反复解释累不累，反正我是累了，别慌，就信来了。 context engine dot opencloud 的 智能上下文管理器， 它能干啥？智能筛选消息，精准压缩历史，突破了空限制，还能自己扩展？一句话让 ai 真正记住你说的话，咋用呢？三步超简单。第一步，看看当前引擎，在终端里跑一下 opencloud doctor 命令，这个命令会检查系统状态，或者直接用 kate 命令看配置文件， 文件位置在用户目录下的 open call 点 j 上，用 jq 工具筛选出 case 键的配置。如果返回直是 legacy， 说明用的是内置引擎。如果是插件 id， 说明已经装了插件引擎， 就这么简单。第二步，装个插件引擎，还是在终端里跑 open call in store 这个命令后面跟插件名字，插件名是 losloslog， 来自 motion engineering 这个组织， 这是从 npm 安装，强烈推荐 lostslaw 这个插件，无损压缩效果杠杠的，也可以从本地安装加个横杠 l 参数，后面跟上本地路径就行，适合开发调试。第三步，配置一下，打开 openclaw， 点接上这个配置文件，找到 plugins 配置，像 在 slot 下面加上 context engine， 直设成 lostslaw， 然后在 entries 里面加上 lostslaw 的 配置，把 enable 设成 true 保存就完事了。 记住了啊，改完配置必须重启 gateway， 不 然白搭。重启命令是 opencall gateway restart。 想切回内置引擎，把 context engine 的 值改回 legacy 就 行，或者直接删掉。这横配置 效果咋样？三个字爽翻了！超长对话随便聊，关键信息全保留，还能自己定制策略，我用下来感受对话顺畅多了， ai 理解也更准了。这总结一下，三步走，检查安装配置激活、告别 token 限制，让 ai 真正记住你的话。觉得有用，关注我，大叔大更多 openclaw 干货，咱们下期见！
110大书大
01:07查看AI文稿AI文稿分享一个 kol 的 小技巧，在你这个 kol 的 code 里面，使用第三方模型的时候，比如说 deepink 四 v 四 pro， 它明明是有一千个 k 的 上下文，但实际上这里它只会写成两百，为什么？因为 你的这些第三方模型的 kol 它不认识，它并不知道你的上下文是多大，所以它默认都是给两百，直接切成两百，这样的话你问一个问题就能耗掉接近五十，你这个一个对话 基本上四五个问题，他就要被墙压住了，那肯定是很不爽的，那怎么办？有个小技巧，其实就是你要选择模型的时候， 你要跟他讲你的上下文长度是多少，那怎么讲呢？他是这么约定的，你后面跟个中括号就这样子， 如果你是要改成三百 k， 你 就改成这样子，如果你要一千个 k， 你 就直接写成一个 m 就 行，这样子他就会被识别的一千个 k 就是 一个 m 的 上下文， 这样的话，你记在这个里面，可以完整的问他几十次问题，五十次问题，他才会触发上下往下缩，这样的话你的这个使用的会很舒服。对，就这么一个小技巧，一分钟教给大家。
05:04查看AI文稿AI文稿大家好，今天是上下文工程系列第十一期。有朋友问，上下文压缩时正纹被玻璃只留摘样，缓存命中率会下降吗？这个问题要分两种情况看，上下文没满时和将满时机制完全不同。上下文没满时，前缀不动，缓存命中率完全不受影响。 将满时那一轮压缩，缓存失效，命中率下降一次，后续不受影响。要搞懂为什么，得先聊清楚缓存到底怎么命中。这期聊两件事，第一， prompt catching 到底怎么命中。第二， cloud code 的 compaction 源码里怎么做到压缩但不费缓存？简单说， prompt catching 管的是接口层的缓存附用， compaction 管的是应用层的上下文压缩，一个在云端管附用，一个在本地管长度，两层配合长对话，才能既便宜又不丢信息。 先看 prompt catching， 这是 antropic 提供的接口级缓存机制，相同前缀跨请求赋用，不是与异相似。匹配有三个关键点。第一个关键点， 核心机制，从头逐字符匹配，匹配到的前缀直接赋用，只计算新增部分。关键点二，省钱，命中的部分只收原价的百分之十，省了百分之九十。第三个关键点，省十， 前缀不用重新计算，首字母出的更快，延迟也会缩短， a 阵特越聊越快。约束有三条前缀必须逐字母完全一致，有最小长度门槛，有过期时间，命中后会重置计时。 搞懂机制之后，来看一个停反直觉的现象，两个对比，正常情况，系统提示加加要这段前缀保持不变，每一轮都能命中绿色部分，不用重复计算 异常情况，你在中间删了一个字符，哪怕只是删掉加要里的一个标点，从删除点往后，所有字符的位置都变了。缓存从分叉点后全部失效， 受影响的字符从原价的十分之一跳回原价删一个字符，单字价格最多涨十倍，这是单字符价格倍率，不是整轮总成本上线。整轮成本的影响取决于分叉点的位置。现在回到开头那个问题，新内容追加时，缓存会费吗？ 三轮对话来看，颜色区分了三种状态，蓝色是首次请求写入缓存，绿色是前缀命中缓存，橙色是本轮新追加的内容。 第一轮系统提示加十条加要再加用户问题，缓存写入，这是首轮请求。第二轮，用户追问文档三 a 键，它不是把加要三替换成文，而是把文三追加到尾部， 前缀不变，缓存继续命中。第三轮追问，文档四全文四继续往后夹，前缀还是没动，继续命中。关键就是新内容只往后夹 前面，没动前缀照样命中。渐近式，譬如控制读多少， prompt 开庆复用已经算过的，互补不矛盾。单 a 正替场景最直观，多 a 正替也一样。 前面讲了 prompt catching 怎么命中。现在来看， cloud code 源码里这两件事是怎么配合的？没满时怎么保缓存？满了之后怎么压缩再重建？左边是主循环，右边是两个文件的实际实现。主循环还是 while two？ 每一轮先判断要不要压缩，如果需要压缩就重建前缀，如果不需要，注意看 else 分 支消息数组不变，前缀相同，缓存继续命中。这就是不压缩时缓存不受影响的代码级证据。 右边第一个文件判断逻辑， toc 数没超裕值，直接返回不压缩，超过了才触发真正的压缩。另外有个熔断机制，连续失败三次就停止重试。右边第二个文件，压缩加重键先生成加要，重点是保留工具调用， 结果丢了的话， a j t 会重复调用，反而更贵。然后把加要保留的老消息附件组装成一个新数组，这个数组就是新的稳定前缀， 后续每轮请求都用它开头逐字符一致，缓存自然继续命中。所以 compact 不是 删东西，是用一次重建换后续多轮的稳定复用。从源码里能提炼出三条工程规律， cloud code 自己也在遵守，落到我们自己的工程实践里也一样适用。 第一条，稳定内容放最前，系统提示权矩越长越稳。 第二条，新信息追加到尾部，不要往中间插，插入会从插入点往后破坏所有前缀。第三条，压完立刻稳住， 一次压到位，不要连续压两次，每次压缩都是一次缓存重建，连续压等于连续费。总结一下，三个机制各管一件事。渐近式，譬如控制读多少， prompt 开庆控制算多少， compack 神控制何时收合在一起，就是上下文从头放到附用到压缩的完整链路设计时，想清楚这条路径运行时，才不会在质量、成本、延迟之间反复摇摆。 如果你想往深了看，渐近式批露在第六期 code code skills 里有详细拆解记忆设计在第八期讲 code code， 第九期讲 hermes agent compack 审核记忆是两套机制配合着看更完整。本期就到这里， 感觉有所收获的同学可以点赞、收藏加关注，我们下期见！
236新
