ai agent --- redis 缓存

作者:snow来了日期:2026/10/2

一.redis 是什么?

1.概念

Redis(Remote Dictionary Server)是一个基于内存的键值对(Key-Value)数据库,同时也是一个高性能的缓存中间件。

它最大的特点是快——读写操作都在内存中完成,官方标称读性能可达 10 万+ QPS(每秒查询数)。

放在内存里面的东西就叫 缓存,因为程序一断开,内存里面的东西就清空了。

2.为什么radis很快?

  1. 他的数据放在内存里面--不需要读取磁盘
  2. 他是单线程模型--避免多线程上下文切换
  3. 他是基于多路复用(epoll)--单线程也能处理海量并发连接
  4. 他有高效的底层数据结构——如跳表、压缩列表等

3.redis和mysql 对比

4.Redis 在 AI Agent 项目中的核心价值

不管在哪个项目里面,Redis 就是那个站在数据库前面、用内存换速度的"加速层",让你的系统又快又稳。

他的核心价值用一句话说就是:

Redis 能够帮助 Agent 项目解决 记忆、缓存、检索、协调 四大核心需求,让 AI 从"金鱼记忆"变成"有记忆力的助手"。

TTL自动过期

TTL 是 Time To Live(生存时间),指的是数据的"倒计时有效期"。比如用户登录后,系统会在 Session 里设置一个过期时间(比如 30 分钟)。时间一到,这条登录信息会被自动删除,用户下次操作就需要重新登录。这样做的好处是:即使 Session 信息不小心泄露了,它也会在一段时间后失效,降低被冒用的风险。

在redis里面TTL就像一张编签纸的倒计时,你把你要做的事情都写在便签纸上,时间一到,就把编签纸销毁掉,保证你的秘密不会被泄露出去。

多实例共享

一般 aiAgent项目 会部署在多个服务器上,通过负载均衡来分发需求,那如果第一个请求给了A 服务器(A分身),第二个请求给了B服务器(B分身),B 又不知道 A 回答了什么,怎么办?

这时候,你可能会每次都将历史数据全部带上之后再发送请求。这样做有几个坏处:

  • 1.你将和问题不相关的历史数据发送给了大模型,此时就会干扰大模型的回复。
  • 2.你的历史数据超出了限制,想带的没有带上,不想带的进入了大模型,大模型阅读历史数据也需要token。

还有没有更好的办法呢?有就是redis,此时它就成了我们不可或缺的帮手。

Redis 就是中间那张公共办公桌,所有分身都往这张桌上放东西、拿东西,谁都能看到。不管用户换到哪个分身,记忆都在。

持久化

内存里存东西最大的问题就是:一断电全没了。用户聊了半天,服务器重启,记忆全丢,用户体验直接崩塌。

Redis 的 RDB/AOF 就像定期把便签纸拍照存档 + 每写一条就记一笔日志,服务器挂了重启之后,记忆能恢复回来,用户毫无感知。

丰富的数据结构

redis 里面有仿佛的数据结构, 而 agent 要存的东西也五花八门:

  • 存一段对话文本 → 用 String(就像便利贴,一个名字对应一段内容)
  • 存用户资料(姓名、年龄、偏好)→ 用 Hash(就像一张表格,一行一个字段)
  • 存任务队列(待办事项列表)→ 用 List(就像排队取号的号码牌)

Redis 不是只能存一种东西,而是各种形状的都有,拿来即用。

语义检索

Redis 在 RediSearch 模块(Redis 7.2+)中加入了向量索引支持,到 Redis 8.0​ 直接把 RediSearch 并入内核,变成了原生的向量检索能力。

换句话说,Redis 在内存里存数据,本身就擅长"快速找东西"。而向量检索的本质也是"快速找相似的数据"——Redis 只是在自己已有的存储引擎上,加了一层向量索引算法(HNSW/FLAT) ,让它能按"语义相似度"来找数据,而不只是按 key 精确查找。

消息队列

Redis 消息队列在 Agent 项目里干的就是 "把慢的、容易挂的、易超时的,容易并发打架的动作,从主链路里拎出来排队"。

轻量异步用 List,要可靠和分活用 Streams;消息体只放 ID,别往里塞大东西;量大了别硬扛,换专业 MQ。

5.deepagent的subAgent的中间件和langgraph都可以给多个agent排序,为什么还要用redis的消息队列去管子agent的事情?

Agent 框架(DeepAgent / LangGraph / CrewAI)管的是"谁做什么、怎么做"——也就是编排逻辑。

Redis 管的是"任务放在哪、谁抢到了、别抢重复了、崩了怎么办"——也就是运行时支撑。

框架是大脑,Redis 是手和脚。 ​ 大脑想清楚了,活还得靠手干。

框架的 SubAgent 调度​ = 你在办公室里,口头喊三个同事帮你干活

  • 人都在、都在线、事情不多 → 没问题
  • 人突然走了(进程重启)、事情堆成山(突发流量)、要跨办公室(多机部署)→ 就乱了

Redis 消息队列​ = 公司前台放了个任务登记本

  • 谁来都看登记本,谁做完划掉一条
  • 人走了,本子还在
  • 新来一个人,直接翻本子干活
  • 活太多排着队,不会挤爆办公室

说明一个问题,deepagent的subAgent的中间件和langgraph都可以给多个agent排序,只是在规划,做完这件去做那件。可是在真正运行的时候就,会出现运行比较慢的节点,那么redis就会把这个缓慢节点从主链路里摘出去,将任务丢进消息队列里面,在后台慢慢跑,此时主进程就可以立刻返回。

框架负责"谁先谁后"的编排;Redis 负责"活怎么可靠地跑起来、怎么不被慢节点拖垮、怎么不被流量冲垮"。

6.Redis 的使用场景

场景一:多副本部署

110 个 Pod 都跑同一套 LangGraph
2→ Pod A 跑到一半挂了
3→ 请求被负载均衡转到 Pod B
4→ Pod B 凭 thread_id 从 Redis 读出 checkpoint,接着往下跑
5

没 Redis?Pod B 什么都不知道,用户只能从头来。这是 Redis 不可替代的场景。

场景二:长任务不能阻塞 HTTP

LangGraph 的 super-step 是同步的,一个节点没跑完,图就停在那。Agent 调搜索、跑脚本要 5 分钟,网关 30 秒超时直接断。

Redis Streams 在这里是把长任务从 HTTP 链路里摘出去:

1HTTP 请求 → 建 thread + 写初始 checkpoint → 投一条消息进 Stream → 立即返回 task_id
2消费者(另一组进程)→ 读消息 → 推进图 → 每步写 checkpoint → 完成写结果
3前端 → 拿 task_id 轮询 / 订阅拿结果
4

图的编排还是 LangGraph 的,Redis 只是承载了"待办任务"和"每一步的状态快照" 。

场景三:突发流量

1000 个请求同时进来,模型 API 和下游扛不住。框架的并发调度只管"同时跑几个",不管"要不要排队" ——它会照实开满,然后打爆下游。Redis 队列负责限速匀速消费。

场景四:失败重试与死信

框架不提供"失败 3 次进死信队列"这种机制。Redis Streams 的 XACK + 重试 + dead letter,是专门干这个的。


什么时候确实不需要 Redis

如果你的场景是单进程、单 Pod、任务几分钟能跑完、崩了重跑也没关系,那:

  • DeepAgent 的 SubAgentMiddleware 足够了
  • 或者 LangGraph + MemorySaver 也足够了
  • 上 Redis 反而是过度设计

2.redis 的ai Agent项目

2.1.安装

1docker run -d --name redis -p 6379:6379 redis:7-alpine
2

redis不支持windows,因为 Redis 从 3.2 起就停掉了 Windows 的官方维护。也可以在 docker 上安装。

2.2.在nodejs 里面操作redis

1import Redis from 'ioredis';
2
3// 创建 Redis 客户端
4const redis = new Redis({
5  host: 'localhost',
6  port: 6379,
7  db: 0
8});
9
10// 监听连接
11redis.on('connect', () => {
12  console.log('✅ ioredis 连接成功(mjs 版)');
13});
14
15// 错误监听
16redis.on('error', (err) => {
17  console.error('❌ Redis 连接失败:', err);
18});
19
20// 执行操作
21async function runRedisDemo() {
22  try {
23    // =========================
24    // 1. String 字符串
25    // =========================
26    await redis.set('name', '张三');
27    await redis.set('code', '6666', 'EX', 300); // 5 分钟过期
28    console.log('String name:', await redis.get('name'));
29
30    // =========================
31    // 2. Hash 哈希
32    // =========================
33    await redis.hset('user:1001', 'name', '李四', 'age', 28);
34    console.log('Hash user:', await redis.hgetall('user:1001'));
35
36    // =========================
37    // 3. List 列表
38    // =========================
39    await redis.lpush('task:list', '任务1', '任务2');
40    await redis.rpush('task:list', '任务3');
41    console.log('List:', await redis.lrange('task:list', 0, -1));
42
43    // =========================
44    // 4. Set 集合
45    // =========================
46    await redis.sadd('tag:set', 'redis', 'nest', 'node');
47    console.log('Set:', await redis.smembers('tag:set'));
48
49    // =========================
50    // 5. ZSet 有序集合
51    // =========================
52    await redis.zadd('score:rank', 99, '小明', 95, '小红');
53    console.log('ZSet 排名:', await redis.zrange('score:rank', 0, -1));
54
55    // =========================
56    // 6. 分布式锁(标准写法)
57    // =========================
58    const lockKey = 'lock:order:1001';
59    const lockResult = await redis.set(lockKey, 'locked', 'NX', 'EX', 10);
60    console.log('分布式锁:', lockResult ? '加锁成功' : '加锁失败');
61
62  } catch (err) {
63    console.error('执行异常:', err);
64  }
65}
66
67// 运行
68runRedisDemo();
69
70

2.3 redis 存数会话上下文

我们在控制台实现一个和大模型的对话agent,采用nodejs实现。

在一般的 ai agent 项目里面使用 redis 来存储会话的上下文。他的代码逻辑就是在invoke之前加载redis里面的缓存数据,然后在invoke拿到大模型的回复以后,将回复保存到redis里面。

主要代码如下:

import { mapChatMessagesToStoredMessages, mapStoredMessagesToChatMessages, } from "@langchain/core/messages";是用来做message序列化的工具,

1存进 Redis 时:
2  HumanMessage 实例 ──mapChatMessagesToStoredMessages──→ 纯 JSON(可序列化)
3
4从 Redis 读时:
5  纯 JSON ──mapStoredMessagesToChatMessages──→ HumanMessage 实例(可喂给 Agent)
6

我们用import * as readline from "node:readline/promises"; import { stdin , stdout } from "node:process";实现在控制台上读取用户输入的问题和大模型输出的答案。模拟前端调用接口,拿到问题,返回答案的场景。

stdin 是键盘输入流,stdout 是屏幕输出流。 传给 readline.createInterface({ input: stdin, output: stdout }),就是告诉 readline:从键盘读、往屏幕写——于是你在终端里就能一行一行地和程序对话。

summarizationMiddleware 是 Agent 的"记忆压缩器"——当对话消息累积太多时,自动把前面的内容总结成一段摘要,腾出空间,同时尽量不丢重要信息。----就是总结

代码详情:

1pnpm install @langchain/langgraph @langchain/openai deepagents dotenv langchain zod
2
1/**
2 * 基于 Redis 的 Agent 短期记忆 
3 *
4 * 模式:
5 * - invoke 前:从 Redis 读取该会话的 messages
6 * - invoke 后:把 agent 返回的 messages 写回 Redis(带 TTL)
7 * - 压缩:由 langchain summarizationMiddleware 在 agent 内部完成
8 *
9 * 前置:docker compose up -d redis
10 *
11 * 运行:node src/agent-with-redis-memory.mjs
12 * 输入 exit / quit / :q 退出;:clear 清空当前会话记忆
13 */
14import "dotenv/config";
15import Redis from "ioredis";
16import * as readline from "node:readline/promises";
17import { stdin , stdout } from "node:process";
18import { ChatOpenAI } from "@langchain/openai";
19import {
20  mapChatMessagesToStoredMessages,
21  mapStoredMessagesToChatMessages,
22} from "@langchain/core/messages";
23import { createAgent, HumanMessage, summarizationMiddleware } from "langchain";
24
25const REDIS_HOST = process.env.REDIS_HOST ?? "localhost";
26const REDIS_PORT = Number(process.env.REDIS_PORT ?? 6379);
27const REDIS_DB = Number(process.env.REDIS_DB ?? 0);
28const MEMORY_TTL = Number(process.env.MEMORY_TTL_SECONDS ?? 1800);
29const KEY_PREFIX = process.env.MEMORY_KEY_PREFIX ?? "agent:short_memory";
30const SESSION_ID = process.env.MEMORY_SESSION_ID ?? "demo_user_001";
31
32const summaryPrompt = `你是对话摘要助手。请用中文总结以下对话,包含:
331. 讨论的主要话题
342. 用户提到的重要事实(姓名、偏好、日期等,务必保留原文信息)
353. 继续对话所需的关键上下文
36
37保持简洁,不要编造,不要遗漏用户明确说过的信息。
38
39待摘要的对话:
40{messages}
41
42摘要:`;
43
44class RedisMessageStore {
45  constructor({ redis, keyPrefix, ttlSeconds }) {
46    this.redis = redis;
47    this.keyPrefix = keyPrefix;
48    this.ttlSeconds = ttlSeconds;
49  }
50
51  messagesKey(sessionId) {
52    return `${this.keyPrefix}:${sessionId}:messages`;
53  }
54
55  async loadMessages(sessionId) {
56    const raw = await this.redis.get(this.messagesKey(sessionId));
57    if (!raw) return [];
58    return mapStoredMessagesToChatMessages(JSON.parse(raw));
59  }
60
61  async saveMessages(sessionId, messages) {
62    const payload = JSON.stringify(mapChatMessagesToStoredMessages(messages));
63    await this.redis.set(this.messagesKey(sessionId), payload, "EX", this.ttlSeconds);
64  }
65
66  async clear(sessionId) {
67    await this.redis.del(this.messagesKey(sessionId));
68  }
69
70  async ttl(sessionId) {
71    return this.redis.ttl(this.messagesKey(sessionId));
72  }
73}
74
75async function invokeWithMemory(agent, store, sessionId, userText) {
76  const history = await store.loadMessages(sessionId);
77  console.log(`  ↳ 从 Redis 加载 ${history.length} 条历史`);
78
79  const result = await agent.invoke(
80    { messages: [...history, new HumanMessage(userText)] },
81    { recursionLimit: 30 },
82  );
83
84  await store.saveMessages(sessionId, result.messages);
85  const ttl = await store.ttl(sessionId);
86  console.log(`  ↳ 写回 Redis ${result.messages.length} 条 (TTL ${ttl}s)`);
87
88  return result;
89}
90
91const redis = new Redis({ host: REDIS_HOST, port: REDIS_PORT, db: REDIS_DB });
92
93redis.on("connect", () => console.log("✅ Redis 已连接"));
94redis.on("error", (err) => console.error("❌ Redis 错误:", err.message));
95
96const store = new RedisMessageStore({
97  redis,
98  keyPrefix: KEY_PREFIX,
99  ttlSeconds: MEMORY_TTL,
100});
101
102const model = new ChatOpenAI({
103  model: process.env.MODEL_NAME,
104  apiKey: process.env.OPENAI_API_KEY,
105  configuration: { baseURL: process.env.OPENAI_BASE_URL },
106  temperature: 0,
107});
108
109const agent = createAgent({
110  model,
111  tools: [],
112  systemPrompt:
113    "你是会话助手。记住用户提到的关键事实,中文简短回答。若消息中有对话摘要,请据此继续对话。",
114  middleware: [
115    summarizationMiddleware({//总结压缩
116      model,
117      summaryPrompt,
118      trigger: { messages: 8 },
119      keep: { messages: 4 },
120    }),
121  ],
122});
123
124console.log("输入 exit / quit / :q 退出,:clear 清空记忆\n");
125
126const rl = readline.createInterface({ input: stdin, output: stdout });
127let prevCount = (await store.loadMessages(SESSION_ID)).length;
128
129try {   
130  while (true) {
131    const userText = (await rl.question("你: ")).trim();
132    if (!userText) continue;
133
134    if (["exit", "quit", ":q"].includes(userText.toLowerCase())) break;
135
136    if (userText === ":clear") {
137      await store.clear(SESSION_ID);
138      prevCount = 0;
139      console.log("已清空当前会话记忆\n");
140      continue;
141    }
142
143    const { messages } = await invokeWithMemory(agent, store, SESSION_ID, userText);
144    console.log("\n助手:", messages.at(-1)?.content);
145    console.log(`当前消息数: ${messages.length}`);
146    if (messages.length < prevCount + 2) {
147      console.log("  ⚡ 已触发压缩");
148    }
149    prevCount = messages.length;
150    console.log();
151  }
152} finally {
153  rl.close();
154}
155
156await redis.quit();
157
158

测试就是长这样的

2.4 redis 存储 langgraph 的状态

如果"存状态"指的是 LangGraph 图的运行状态(断点续跑),那确实只能用 Checkpointer——它是 LangGraph 内置的唯一机制。

但如果"存"指的是对话记忆(让 Agent 记住上下文),那不用 Checkpointer 也完全行,自己写 load/save 到 Redis 就行,你之前那份代码就是这么干的。

Checkpointer 是"图状态"的官方方案;"对话记忆"是另一条独立的线,可以自由选择存储方式。

Checkpoint 就是 LangGraph 每一步跑完的"存档快照"——存的是跑到哪了、手里有什么。崩了能续、人能介入、历史能回看。Checkpoint 存在 Redis 里,就能跨进程/跨服务实例共享——不管请求被分到哪个实例上,都能读到存档接着跑。

我们利用checkpointer是为了存储langgraph图的运行状态,如果你要是存储对话的上下文,你就可以不用checkpointer。

1npm install @langchain/langgraph @langchain/core @langchain/langgraph-checkpoint-redis ioredis
2
1import { StateGraph, Annotation, MemorySaver } from "@langchain/langgraph";
2import { RedisSaver } from "@langchain/langgraph-checkpoint-redis";
3import { Redis } from "ioredis";
4
5// ── 1. 状态定义(决定 Checkpoint 里存什么)──────────────
6const GraphState = Annotation.Root({
7  messages: Annotation<string[]>({
8    reducer: (left, right) => left.concat(right),
9    default: () => [],
10  }),
11  step: Annotation<number>({
12    reducer: (_left, right) => right,
13    default: () => 0,
14  }),
15});
16
17// ── 2. 节点:就是普通函数 ──────────────────────────────
18const researchNode = async (state: typeof GraphState.State) => {
19  return {
20    step: state.step + 1,
21    messages: [...state.messages, "调研完成:找到 3 个竞品"],
22  };
23};
24
25const analyzeNode = async (state: typeof GraphState.State) => {
26  return {
27    step: state.step + 1,
28    messages: [...state.messages, "分析完成:建议差异化定价"],
29  };
30};
31
32// ── 3. 连图 ────────────────────────────────────────────
33const builder = new StateGraph(GraphState)
34  .addNode("research", researchNode)
35  .addNode("analyze", analyzeNode)
36  .addEdge("__start__", "research")
37  .addEdge("research", "analyze")
38  .addEdge("analyze", "__end__");
39
40// ── 4. 关键:把 RedisSaver 注入进去 ─────────────────────
41const redis = new Redis("redis://localhost:6379");
42
43const saver = new RedisSaver({ client: redis });
44await saver.setup();                     // 首次建索引,必须 await
45
46const graph = builder.compile({ checkpointer: saver });
47
48const config = { configurable: { thread_id: "user_123" } };
49
50// 第一次:从头跑,两个节点都执行
51const r1 = await graph.invoke(
52  { messages: [], step: 0 },
53  config
54);
55console.log(r1);
56// { messages: ["调研完成...", "分析完成..."], step: 2 }
57
58// 第二次:同 thread_id,自动从 Checkpoint 恢复
59const r2 = await graph.invoke(
60  { messages: ["再细化一下"], step: 2 },
61  config
62);
63

最关键的代码是

const graph = builder.compile({ checkpointer: saver }); 这句话将checkpoint ,langgraph,redis三者相连的关键代码。它每跑完一个节点,就把当前整个 state 序列化,交给这个 saver 去存储。

在正常的项目里面是这样设置的:

1// 开发测试:存在内存里
2const graph = builder.compile({ checkpointer: new MemorySaver() });
3
4// 生产环境:存在 Redis 里
5const graph = builder.compile({ checkpointer: saver });
6
7// 要求强一致:换 PostgresSaver,图的逻辑一行不用改
8
  • new Redis(...) 建立一条连到本地 6379 端口 Redis 的网络连接。
  • new RedisSaver({ client: redis }) 创建一个存档器,它知道"Checkpoint 怎么序列化、怎么读写",并借用第一步的 redis 客户端去实际操作 Redis。
  • await saver.setup() 让 RedisSaver 在 Redis 里把存档所需的索引结构建好(首次部署跑一次即可)。
  • builder.compile({ checkpointer: saver }) 把存档器注入到图的运行时里,告诉 LangGraph:每跑完一个节点,就把当前状态的快照通过 saver 写进 Redis。
  • { thread_id: "user_123" } 是这条对话的存档编号,作为 Redis 里的 key——同一个 thread_id 下次调用时能读出存档、从断点继续;换个 thread_id 就是一条全新的对话。

说白了就是:redis(客户端)负责"连",RedisSaver(存档器)负责"怎么存",setup() 在 Redis 里"建好存放的架子",compile() 让 LangGraph"跑完就往里放"。


参考文档


《ai agent --- redis 缓存》 是转载文章,点击查看原文。


相关推荐


DeepSeek Harness 系列图解
怕浪猫2026/9/26


Linux系统——基础IO(上)
进击的荆棘2026/9/18

💁‍♂️个人主页:进击的荆棘 👇作者其它专栏: 《数据结构与算法》《算法》《C++起始之路》《Linux》 目录 1.理解“文件” 2.C文件接口 3.系统文件I/O 4.理解“一切皆文件” 5.缓冲区 1.理解“文件” 1.1狭义理解 ●文件在磁盘里 ●磁盘是永久性存储介质,因此文件在磁盘上的存储是永久性的 ●磁盘是外设(既是输出设备也是输入设备) ●磁盘上的文件本质是:对文件的所有操作,都是对外设的输入和输出,检查IO 1.2广义理解 ●L


密码管理工具站正式上线啦
乱码三千2026/9/10

前言 互联网时代要存储的密码实在太多, 脑袋压根记不过来, 只能借助外物, 比如存到便签里, 或者建一个Excel表格, 但是存在两个问题, 那就是安全性和便捷性不够 我的要求是随时随地都能查看、编辑、保存和新增密码, 无论是外出还是在家, 也不管是使用电脑还是手机, 可以进行无缝切换 其实苹果自带的密钥就很好用, 但是局限于苹果设备, 万一哪天换安卓了, 就很尴尬, 虽然支持云端存储, 但是不能导出到本地, 安全性和便捷性还是不足 便签的话更不用说了, 明文显示, 安全性极差 既然存到第三方平


同一份 15 个流程 JSON,第六种语言也跑通了:工作流引擎 Rust 移植实录
mldong2026/9/2

一、第六格不是"翻译" 这个系列写过五门语言的工作流引擎:Java、Go、Python、Node、PHP。五门语言读的是同一份东西——引擎仓库里 flows/ 目录下的 15 个流程 JSON:简单审批、多任务、条件路由、fork-join、三种会签、退回发起人、混合模式……六语言 demo 共读这一个目录,改一处,六边验证。 第六种语言是 Rust。 先说清楚一件事,免得标题被误读:Rust 里不缺"工作流引擎"——做任务编排(durable execution)的有 Temporal、wor


OpenTelemetry Java 扩展:无需分叉 agent 即可自定义追踪
Elasticsearch2026/8/25

作者:来自 Elastic Sylvain Juge 一个 JAR 文件,在 OpenTelemetry Java agent 启动时加载,就可以过滤健康检查、重命名 span、添加资源属性以及控制采样,而无需修改应用程序代码。 你刚刚为一个 Java 应用设置了自动插桩。无需修改任何代码,追踪数据就开始流向你的可观测性平台。几分钟后,你发现健康检查端点正在大量充斥你的追踪视图,而且事务名称反映的是通用的框架模式,而不是你的业务领域操作。 分叉 agent 可以解决这个问题,但这样一来,你就需


把 Agent 做成一家公司,真比通用提示词好用吗?
苏灿烤鱼2026/8/12

它卖的不是一个万能 Agent,而是一套可挑选、可安装的 AI 专业分工。 ⚡️ 30 秒速读:msitarzewski/agency-agents 以 143,086 星、今日 +971 登上 GitHub Trending #1,连续 3 天在榜,排名从 #3、#2 升到 #1。它把不同专业角色写成独立 Agent 文件,每个文件包含身份与性格、核心任务与工作流、带代码示例的技术交付物、成功指标和沟通风格;可用原生桌面应用或 Shell 脚本安装到 Claude Code、Cursor、


Vite 8.1 深度拆解:Rolldown 统一打包器如何终结前端构建的「双引擎时代」
NutShell Wang2026/8/2

2026 年 3 月 12 日,Vite 8.0 正式发布,将 Rolldown——一个用 Rust 编写的打包器——作为唯一打包引擎引入,取代了此前 esbuild(开发)+ Rollup(生产)的双引擎架构。这被官方称为「自 Vite 2 以来最重大的架构变更」。三个月后的 Vite 8.1(6 月 23 日发布)进一步推出了实验性打包开发模式,在 10,000 个 React 组件的测试中实现了约 15 倍的启动加速。与此同时,Rolldown 本身也在快速迭代——1.0 正式版于 5 月


线程栈与TLS和线程互斥
keyipatience2026/7/25

线程栈 主线程(进程 main 栈)特性: (1)来源:fork 复制父进程栈 (2)可动态自动扩容 (3)缺页容错特殊:允许访问未映射页、不一定直接段错误的栈 线程栈 mem = mmap(NULL, size, prot, MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0); 标志MAP_STACK:专门标记这块内存用作线程栈;默认固定 8MB 大小(一般够用),不支持动态扩容,空间用完直接栈溢出崩溃;属于进程虚拟地址里一块独


如何用 AI 协助解决陌生技术问题:拆解-分析-熟悉-解决四步法
dozenyaoyida2026/7/17

你接过陌生项目吗?那种打开 IDE,几千个文件铺开,光看目录名就头大,盯着屏幕两小时一行代码没写的感觉。 或者更常见的,线上突然报了个错,涉及一个你从没读过的模块,老板在群里 @ 你,你点开文件,密密麻麻的调用链,不知道从哪开始查。 我做了十年开发,最近两年重度用 AI 辅助。最大的体会是,面对陌生问题,卡住你的从来不是"难",是"乱"。你不知道从哪下手,不知道自己不知道什么,于是在原地打转。 下面这套方法我用了几十次,核心就四个字:拆解、分析、熟悉、解决。AI 在每个阶段扮演的角色不一样,你介


【从零开始大模型开发与微调:基于PyTorch与ChatGLM】(基于PyTorch卷积层的MNIST分类实战:从卷积直觉到高效卷积设计)
承渊政道2026/7/9

🔥承渊政道:个人主页 ❄️个人专栏: 《C语言基础语法知识》 《数据结构与算法》 《C++知识内容》 《Linux系统知识》 《算法刷题指南》 《测评文章活动推广》 《大模型语言路线学习》 《MySQL数据库学习》 《Python知识内容》 ✨逆境不吐心中苦,顺境不忘来时路!✨ 🎬 博主简介: 前面使用多层感知机完成了MNIST分类实战的演示.多层感知机是一种对目标数据进行整体分类的计算方法.虽然从演示效果来看,多层感知机可以较好地完成项目

首页编辑器站点地图

本站内容在 CC BY-SA 4.0 协议下发布

Copyright © 2026 聚合阅读