Redis与AI代理内存：Andrew Brookins分享

设计AI代理的一个关键挑战在于，大型语言模型是无状态的且具有有限的上下文窗口。

A key challenge with designing AI agents is that large language models are stateless and have limited context windows.

这需要精心的工程设计，以确保在连续LLM交互中保持连续性和可靠性。

This requires careful engineering to maintain continuity and reliability across sequential LLM interactions.

为了表现良好，代理需要快速系统来存储和检索短期对话、摘要以及长期事实。

To perform well, agents need fast systems for storing and retrieving short term conversations, summaries, and long term facts.

Redis是一种开源的内存数据存储，广泛用于高性能缓存、分析和消息代理。

Redis is an open source, in memory data store widely used for high performance caching, analytics, and message brokering.

最新进展已扩展Redis的能力至向量搜索和语义缓存，这使其日益成为AgenTic应用堆栈中的热门组件。

Recent advances have extended Redis' capabilities to vector search and semantic caching, which has made it an increasingly popular part of the AgenTic application stack.

Andrew Brookins是Redis的首席应用AI工程师。

Andrew Brookins is a principal applied AI engineer at Redis.

他与Sean Falconer一同参与节目，讨论构建AI代理的挑战、代理中记忆的作用、混合搜索与纯向量搜索的对比、世界模型的概念等内容。

He joins the show with Sean Falconer to discuss the challenges of building AI agents, the role of memory in agents, hybrid search versus vector only search, the concept of world models, and more.

本期节目由Sean Falconer主持。

This episode is hosted by Sean Falconer.

查看节目备注获取更多关于Sean工作的信息以及如何联系他。

Check the show notes for more information on Sean's work and where to find him.

Andrew，欢迎来到我们的节目。

Andrew, welcome to the show.

谢谢。

Thank you.

感谢邀请。

Thanks for having me.

我是你们的忠实粉丝，所以这次访谈很有趣。

I'm a big fan, so this is fun.

不错。

Nice.

是啊。

Yeah.

很高兴你能来参加，我们终于把时间安排妥当了。

Well, I got glad you could be here while we could work it out.

节目里有粉丝参与总是件好事。

Always good to have a fan on the show as well.

确实如此。

Absolutely.

所以我想要先从宏观视角或者一个快速的大局问题开始。

So I wanted to kind of start with the big picture or a big quick picture question.

你认识很多人。

You know a lot of people.

很多人都在说2025年将成为AI智能体的爆发年。

Are saying that 2025 is going to be this breakout year for AI agents.

你知道的，就是智能体之年。

It's you know the year of the agent.

目前市场上有很多炒作的声音。

There's a lot of hype going on in the market right now.

我们正在超越基础的聊天功能。

We're moving beyond just basic chat.

那么从你的角度来看，构建这些更自主的智能体系统有哪些难点？为什么记忆或其他组件在这里扮演如此核心的角色？

So from your perspective, what makes building these more autonomous agentic systems like hard and why does memory or other components kind of play such a central role here?

是的。

Yeah.

嗯，我当然一直在深入思考这个问题。

Well, I think I've been thinking a lot about this, of course.

我认为其中一个主要困难在于，许多我们可以放入概念验证来展示由大语言模型支持的智能体能力的任务，恰恰暴露了大语言模型的弱点。

And one of the reasons I think it's so difficult is that many of the tasks that we can put into a POC to show off what an agent can do backed by an LLM, they satisfy the weaknesses of the LLM.

它们基于信息和训练数据

They draw on information and training.

它们利用生成能力加上上下文工程来高效产出信息

They use that generative ability plus context engineering to produce information effectively.

这些元素确实能做得很好，我们已经做了大量工作让智能体也能做到这一点

And elements can do that really well, we've we've done a lot of work now to make agents be able to do that as well.

对吧？

Right?

但棘手的地方在于，我认为是当智能体需要融入任何环境并实际执行操作时，真正改变某些事物，并且关键是要能够预测这种改变的结果。

But the tricky part is, I think, when the agent has to integrate in any kind of environment and do something, actually change something and crucially, be able to predict, like, the outcome of the change.

而这部分恰恰是，你知道的，大语言模型实际上并未建模的内容。

And that's the part that, you know, LLMs just don't don't model, actually.

它们无法为环境建模那种状态转换。

They don't they don't model state transitions like that for environments.

这正是它们容易失效的地方，也是智能体容易崩溃的环节。

That's where they tend to break down, where agents tend to break down.

那么你认为这是否主要是导致企业困在演示验证阶段，由于这个限制因素而无法推进到产品化层面的原因？

And you think that is that primarily that you know companies get stuck in sort of that, you know, demo POC mode where they just can't move to a productionization standpoint because of that limiting factor.

不是。

No.

我认为那是另一个完全不同的问题，当然也是个问题。

I think that's that's a whole other problem and is also a problem.

我的观点更倾向于：构思'让我们为这个问题构建一个智能体'很简单，但更难的是分析问题本身，并将其映射到智能体真正擅长的领域，以及你需要做些什么才能让它在特定任务中表现出色。

I think it's more along the lines of it's really easy to think about, well, let's build an agent for this problem, but it's harder to think about the problem and map that back to what the agent will actually be good at and what if what you will need to make it good at certain tasks.

因此，用智能体和大型语言模型解决某些问题，需要更多考虑预测组件，而不仅仅是聊天机器人这类应用。

So tackling certain problems with an agent and with an LLM require more thought about the predictive component beyond just, you know, chatbots and things like that.

然后还有整个关于如何从概念验证阶段走出来，真正实现有意义的规模化生产部署的问题。

And then there's the whole side of get just getting out of the POC phase and getting things into production in any meaningful capacity.

这个问题本身由于其他原因也是个重大挑战。

And that itself is also a large problem for other reasons.

嗯。

Mhmm.

是的。

Yeah.

就比如在构建这些智能体系统时，关于记忆功能或挑战，或者说记忆的价值方面的问题——要知道每次调用模型都是无状态的。

Is in terms of like some of the challenges around memory or the value of memory when building some of these agentic systems, you know, every sort of call to the models stateless.

当然它们还有容量限制，比如你能在上下文中发送多少信息给它们。

So and then of course they have a limited capacity in terms of like how much information you can be sending to them in the context.

那么你需要考虑的记忆组件有哪些？这些如何影响上下文？你又该如何解决在正确时机提供正确上下文的优化挑战呢？

So what are sort of the components of memory you need to be thinking about and how do those influence context and how do you work through sort of the optimization challenges of feeding it the right context at the right time?

是的，完全同意。

Yeah, absolutely.

好问题。

Great question.

我认为关于记忆的思考，甚至在你的问题中，就隐含了一些关于它究竟是什么、属于什么类型的假设。

So I think thinking about memory, you know, even in your question, right, there's some implicit assumptions about what what it is exactly, what type of thing it is.

每次我和人们讨论记忆时都会遇到这种情况，这非常有趣。

This happens all the time when I talk to folks about memory, and and it's really interesting.

最基础的层面来说，如果我们甚至不讨论智能体，就像网页应用那样——我是用户，访问网页应用，进行操作，返回时希望它能延续上次的进度。

So the most basic level, right, if we just are not even talking about agents, if we're just talking like a web application, I'm a user, I go to a web application, I do something, I come back, I expect it to continue where we left off.

对吧？

Right?

这本质上就是一种有状态的交互。

It's just like fundamentally, they're stateful interactions.

大多数场景都是这种延续性的有状态交互。

Most things are just a stateful interaction where it continues.

而LLM作为更复杂应用中的一个组件本身是无状态的，对吧？

And just the fact that the LLM being this component inside of more complex applications is itself stateless, right?

所以我们经常思考这个问题。

So we tend to think about that a lot.

但实际上，就像我们一直构建应用的网络服务器也都是无状态的。

But really it's just kind of like, well, so are all of the web servers that we've been building applications on.

我们需要做些什么才能让它正常工作？

What do we have to do to make that work?

我们需要存储数据。

Well, we have to store data.

我们需要使用数据库。

We have to use a database.

对我来说，关键点在于：好吧，这必须是个前提条件。

And so for me, part is the one that's like, okay, this has to be a given.

在开始构建基于LLM的应用时，我们必须以需要存储数据为前提。

We have to start the process of building something with an LLM with the assumption that we'll have to store data.

这就是一种记忆形式。

And that is a form of memory.

你可以将其映射到2025版记忆盒中的各个小组件。

And you can map this into the 2025 version of what are the small pieces inside of that memory box.

其中通常包含某种消息历史记录。

One of them is typically message history of some kind.

因为很显然，如果要延续对话，你需要过去发送的消息。

Because obviously, if what you're continuing is a conversation, you need the messages that were sent in the past.

因此，消息往往是这种最底层或者说基础的部分。

So messages are they tend to be this lowest level or, you know, fundamental part.

这更多是关于存储，因为我们不需要过多考虑如何存储它。

That's more about storage because we don't have to think a lot about storing that.

我们只需存储消息即可。

We can just store messages.

这本来不是什么大问题，直到它变成大问题——比如用户从未开启过新对话。

It's not a big deal until it is a big deal because, like, the person never started a new chat.

他们实际上从未真正开始过任何事情。

They never actually started anything.

他们只是在同一个数据对话中开始了新的对话。

They just started a new conversation within the same data conversation.

我想我们很多人都见过这种情况。

I think many of us have seen this.

我们都知道现在讨论的核心问题——上下文工程与提示工程（上个月可能还是热门话题）——当消息积累到一定程度时，要准确判断哪些内容与当前问题或输入相关其实相当困难。

Many of us know the whole point that we talk about now, context engineering versus prompt engineering, which was last month probably, is like, it's actually quite difficult at a certain point when you have enough messages to try to figure out what exactly is relevant to the the incoming question or the input.

于是这就变成了一个问题：好吧，这种情况已经持续一段时间了。

And so then it becomes a question of, okay, we've been this has gone on for some time.

我们知道这个模型的局限性，但研究也表明，即使是长上下文模型，尽量精简输入内容仍然很重要，因为它们依然会迷失方向。

You know, we we know the limit of this model, but we also know that research suggests, right, even with long context models, it's still important for us to send as little as possible, right, because they still get lost.

所以关键在于压缩或总结对话内容。

So it's a matter of compacting that or summarizing the conversation.

现在我们讨论的已经是另一个话题了。

And now we're talking about a different thing.

这只是我的个人观点。

This is just my opinion.

对吧？

Right?

所以消息只是数据。

So messages are just data.

我们只是在存储现有的内容。

We're just storing what what we have.

摘要处理开始变成一个超越单纯存储的工程问题，我们需要实际解决如何为这个应用和用户正确总结对话历史，从而减少发送的上下文量。

Summarization starts to become an engineering problem beyond just storage where we have to actually figure out how to get this conversation history for this application and this user summarized correctly so that we can reduce the amount of contacts we're sending.

然后由此继续推进。

And then it goes from there.

对吧？

Right?

那么我就此作结。

So then I'll wrap it up.

对吧？

Right?

但这就像是下一个层级。

But that's like the next level.

更进一步说，想象一个人或认知系统整天与人互动，实际发生的是他们在睡眠时，大脑会在后台线程（可以说是一个进程）中筛选出重要事项并倾向于记住它们。

Beyond that, where if you imagine a person or a cognitive system, let's say, that's interacting with people all day, what's happening is they go to sleep and their brain in a background thread, let's say, a process, picks things out that are important and tends to remember them.

另一种可能是有人57次询问关于玉米饼的事，或者57个人都问起玉米饼，这个人也会记住关于玉米饼的事。

The other thing that can happen is that somebody asks about tacos 57 times or 57 people ask about tacos, and the person also remembers the taco thing.

尽管那可能并不那么重要，但由于出现频率太高，大脑通常会将其烙印下来。

Even though maybe that's not that important, but, like, it's so frequent that they their brain usually, like, stamps it in.

于是就有了这种机制：提取长期事实存入大脑某处，之后再调取出来。

So you get this thing that's extracting long term facts and putting them somewhere in the brain and then pulling them back out later.

这通常就是我们理解的智能体认知系统运作方式。

And that usually is how we think about, like, cognitive system of of an agent.

对吧？

Right?

所以还有第三种情况，就是从对话中提取片段，将它们存放在某处。

So there's that third thing of taking pieces out of this conversation, putting them somewhere.

我们可以在之后使用它们，通常是当用户回来想要再次互动时。

We can use them later, typically when the person comes back, the user, and wants to interact again.

但我们知道一些信息。

But we know something.

我们不需要查看所有总结过的消息历史。

We don't have to look at all of the summarized message histories.

我们只需要知道他们是素食主义者，所以当然会给他们素食食谱。

We just know that they're vegan, and so of course we would give them a vegan recipe.

对吧？

Right?

这就是我思考记忆时考虑的三大方面。

So those are three big areas that I think about with memory.

是的。

Yeah.

此外，还有一类参考数据充当潜在的长期记忆，比如无论我是从向量数据库还是其他类型的数据存储中检索，我可能希望以特定形式引入这部分数据，本质上构成特定上下文的B部分，随后这些内容会被纳入这种循环压缩、循环摘要的循环中，可能在后续周期中再次使用。

And then there's also the sort of reference data that serves as this potential long term memory, like whether I'm looking that up in a vector database or some other type of data store, I might want to pull that in that form a particular, a B part of essentially a particular context, which then gets factored into this sort of loop compaction loop summarization loop that also might be used in a later cycle.

是的，完全正确。

Yeah, absolutely.

思考知识库与长期记忆之间的区别确实很有意思，因为检索过程可能看起来很相似。

It's really interesting to think about what's the difference between the knowledge base and long term memory, for example, because retrieval looks probably similar.

我们会使用混合搜索、向量搜索或关键词搜索来提取信息。

We're going to use hybrid search or vector or keyword search to pull stuff out.

这往往只是时间因素的问题。

It tends to be just a factor of time.

通常长期记忆——我可能与你观点相左，这只是我的思考方式——

Typically long term memory, and again, I'm contradicting you even, I'm just like This is just how I think about it.

长期记忆是我们在运行时学到的内容，也就是智能体学习的内容，而RAG或知识库则更多是我们开发者已知要包含或动态注入的内容，但我们仍明确知道需要注入这些信息。

Long term memory is stuff that we learned, the agent learned at runtime, let's say, whereas Rag or the knowledge base tends to be stuff that we, the developers of the agent, knew to include or we dynamically injected, but still we knew that we wanted to inject it.

所以两者存在细微差别，但最终效果往往非常相似。

So there's a slight difference and but the result tends to be very similar.

我们开始检索它。

We start retrieve it.

是的，而且即使在模型直接交互之外，考虑整个作为智能体的软件部分，因为这些确实是完整的系统。

Yeah, and then even outside of the direct interactions of the model, thinking about the whole piece of software that's like an agent, because these are really full body systems.

这不仅仅是与模型互动那么简单。

It's not like you're just interacting with model.

模型会指示你去调用一个工具，而工具可能会与API进行通信。

The model is telling you to go and call a tool where the tools may be going to communicate with the API.

此外，还有模型之外的其他记忆系统，用于维护状态以确保如果API调用失败你不会重复操作，或者成功时不会多次发起相同调用。

Then there's other sort of memory systems that are part of this outside of the model of how do you maintain state to make sure that if the API call fails, you don't, or it succeeds, you're not making that call multiple times.

这些都属于事件驱动系统或持久化执行等关键特性的范畴。

These types of sort of key characteristics of event driven systems or durable execution and so forth too.

哦，是的，完全同意。

Oh yeah, absolutely.

没错。

Yeah.

这真的很有趣，对吧？

That's really fascinating, right?

所以这就是为什么我认为人们会在这方面犯糊涂，因为它比听起来要复杂得多。

So this is why I think people get tripped up thinking about this because it's so much more complicated than it sounds.

因为即使了解很多这方面的知识，我个人也往往会将代理和模型混为一谈，交替使用。

Because it you you tend to like well, personally, I tend to even knowing a lot of this stuff, I'll tend to think about or talk about an agent and be like, The model, the agent, the model, just interchangeably.

但实际上，它两者都不是。

But actually, it's neither of those things.

它是一个涉及多种不同状态类型的复杂系统。

It's a complex system that involves lots of different types of state.

当人们考虑构建一个能完成复杂任务、进行多重工具调用的深度研究代理时，他们往往没有意识到——也许直到为时已晚，或者恰好在合适的时候意识到——我们实际上是在讨论某种程度上的持久执行。

And when folks think about building out an agent that does complex things, multiple tool calls, a deep research agent, let's say, you know, often what they don't realize perhaps until too late maybe, or they realize and understand in the right amount of time, is that we're really talking about durable execution at some level.

在某种程度上，我们讨论的是动态工作流，在生产环境中它通常会在执行中途失败然后必须重启，或者用户会突然改变主意说'等等，我搞错了'。

At some level, we're talking about dynamic workflow that typically in production is going to die in the middle of something and then have to restart, or the user is going to be like, woah, actually, I was wrong.

这不是一只狗。

It's not a dog.

我刚才看的是一只猫。

It's a cat that I was looking at.

所以先退一步，从我们之前的另一个节点重新开始。

So just back up and start at the other point where we were at.

因此从那个节点重启，就像工作流崩溃后我们需要重新运行，但不必重新执行每个步骤。

And so restarting from that other point, similar to the workflow crashed and we need to rerun it but not re execute every step.

这就是所谓的检查点机制，Landgraf会这么称呼它。

So there's all those checkpointing, right, is what Landgraf would call that.

但这已经存在很长时间了，对吧？

But it's been around for a while, right?

它存在于所有这些不同的工作流系统中。

It's been around all these different workflow systems.

所以没错，完全同意。

So yes, a big yes.

那么说到Redis在这其中的角色，如果我们从短期记忆开始看——这也是我们最初讨论不同记忆系统的起点

So in terms of, you know, Redis' role in all of this, if we look at just starting even with short term memory, which is kind of where we first started talking about, you know, what are these different memory systems?

LMS存在这些有限的上下文窗口。

LMS have these limited context windows.

有些代理可能通过相同的会话或线程进行通信。

You have agents that are maybe communicating over sort of the same session or thread.

如果它与另一个代理交互或与需要追踪的用户交互，就会存在这些来回传递的消息历史记录。

If it's interacting with another agent or interacting with a user that, you know, needs to be tracked, you have those sort of message histories that you're passing back and forth.

Redis在这种架构中扮演什么角色？

Where does Redis fit into that architecture?

在我看来，这与非代理性或确定性的Web应用非常相似。

So, you know, I view it as very similar to a web application that is not agentic or deterministic web application, let's say.

从我的角度看它适合的位置，以及从普通生产工程师的角度看它适合的位置。

You've got the where does it fit from my perspective, and then you've got also where does it fit from the perspective of, you know, random production production engineer.

工程师？

Engineer?

它们往往有重叠，但有些方面我的思考方式可能有所不同。

They tend to overlap, but there are some ways that I tend to think about it differently maybe.

我先说说我的看法。

So I'll give you my perspective first.

首先，我们讨论的是智能体，所以紧扣主题，我们经常会提到短期记忆这个概念，但最近我更倾向于将其视为工作记忆。

First of all, we're talking about agents and of course, so sticking closely to agents, there is this concept of often we'll call it short term memory, but lately, I think about it more as as working memory.

就像人类解决问题需要工作记忆一样，我们需要一个地方来存放当前正在处理的信息。

Just like I need working memory to solve problems as a human being, we need somewhere to put the stuff that we're juggling right now.

对于这些应用场景来说，这通常是指消息历史记录，或者说是我们六个月前已经总结过的历史消息摘要。

And that tends to be, for these applications, a message history or a message history, you know, and a summary of the past message history from six months ago that we summarized already.

因此Redis在这方面绝对是绝佳选择。

So Redis is absolutely a great fit for that.

它速度极快——无论是通过Redis中已有的传统数据结构，还是通过查询引擎（这对开源版本来说算是比较新的功能）。

It's super fast, you know, from just accessing it through the direct, like, data structures that we have in Redis that have been around forever, through the query engine, which is kinda new for, you know, the open source version, I think, as a as a core component of Redis.

这个功能已经包含在Redis8社区版中。

It's in Redis eight community edition and actually yeah.

是的，它就在Redis8里。

So it's in Redis eight.

不过在此之前，它仍然可以通过模块等方式使用。

Before that, though, it was still available in in modules and things.

但我们真正想说的是数据结构——如果你想定义模式并使用查询语言进行查询，Redis同样可以做到。

But really what we're saying is data structures or when you if you wanna define, like, a schema and make queries with a query language, you can also do that with Redis.

无论采用哪种方式，它的速度都极快，比大多数数据处理工具都要快。

In both of those ways, it's extremely fast, faster than most things you're gonna use for for data.

因此对于工作记忆来说非常合适，特别是因为你可以把工作记忆想象成键值查找。

So for working memory, it's a great fit, especially because you can also think about working memory as being, like, key value lookups.

我们非常清楚自己需要什么。

We know exactly what we need.

我们需要获取特定用户的特定数据块，这个数据块就是智能体在工作记忆中处理的内容。

We need that thing for that user, and we'll just pull it out, that blob is what the agent's working with in working memory.

然而作为向量数据库，它在检索方面也能发挥作用。

However, as a vector database, it can also serve a purpose in retrieval.

对吧？

Right?

从知识库中检索内容，你可以将其融入记忆概念或长期记忆中。

Retrieving stuff from the knowledge base that you can incorporate in the idea of memory or from long term memory.

所以如果你长期将这些提取的事实存储在长期记忆中，它在检索方面同样表现出色，速度也非常快。

So if you actually store these extracted facts over time in long term memory, it's great at retrieval as well, also very quickly.

这还不是全部。

So and that's not even it.

对吧？

Right?

实际上，我认为Redis的终极亮点在于流处理。

So actually, it could just final finishing where I view Redis is streams.

我认为流是Redis中一个被严重低估的功能。

I think streams are really overlooked thing perhaps about Redis.

对吧？

Right?

在我最近在Redis负责的生产级智能体中，核心就是后台任务与流处理。

So in the production agent that I most recently worked on at Redis, it's all about background tasks and streams.

我们使用一个名为docket的后台任务库，在流中跟踪这个工作流的状态。

We we track the state of this workflow in streams with a background task library called docket.

所以Redis就在那里帮助我们管理，比如协调这个作为代理的动态工作流的状态。

So Redis is right there helping us manage, like, orchestrating the state of this dynamic work flow that is an agent.

它同时存在于短期记忆、长期记忆以及基于知识的检索中。

It's also there in short term memory and in long term memory and in retrieval for knowledge based stuff.

当然，我现在为Redis工作，所以你知道，我有动力尽可能在所有场景使用它。

Now, of course, I work for Redis, so, you know, I'm incentivized to to use it for everything as possible.

但实际上我是重返Redis工作的。

But I actually came back to work for Redis.

我之前在这里工作过，有一天我正在为一个RAG应用构建代码检索功能，当时用的是Postgres。

I worked here once before, and there was a day I was building out code retrieval for, you know, a rag application basically, and I was using Postgres.

那时候我已经大量使用Postgres，甚至是极端规模级别的Postgres，而它在生产环境中频繁崩溃。

And I had been working with Postgres quite a bit at that time and, like, at at extreme scale levels of Postgres, and it had been crashing in production a ton.

我对Postgres非常恼火，然后意识到用Redis可以完成我正在做的所有事情，而且它能按我期望的方式扩展，速度也会非常快。

I was really angry at Postgres, and I realized that you could do everything I was doing with Redis, and it would scale out the way that I wanted, and it would be really fast.

总之，我们拥有所有这些功能，我认为它们以各种不同方式展现出来。

So anyway, we have all these things and I view them as showing up in all these different ways.

我是说，确实，这项技术已经存在好几年了。

So I mean, right, this has been around for a number of years.

产品中是否有必须扩展的特定功能，以支持我们现在看到的来自智能体或AI领域其他类型应用的新型工作负载，而这些在Redis早期版本中并不具备？

Were the specific things that had to be extended in the product to support some of these kind of new workloads that we're seeing from like agents or other types of applications in the AI realm that weren't already available in in in, you know, prior versions of Redis?

倒不是在最近这段时间。

Not in like immediate recent history.

比方说今年，我认为我们并没有被迫引入什么新功能来解锁这些智能体的应用场景。

Let's say this year, I don't think we've, like, been forced to introduce something new that unlocks one of these one of these use cases with agents.

但长远来看，查询引擎本身就是我们添加到Redis的一个模块，而非核心数据结构。

But, I mean, in the fullness of time, right, like, the query engine itself was a module we added to Redis, not a core data structure.

当我思考Redis为支持这些用例新增了什么时，这对我来说是最重要的一点。

And that's the big one for me when I think about what if what has Redis added to enable some of these use cases?

这就是头等大事。

And that's the number one thing.

对吧？

Right?

能够索引向量，用查询语言动态查询它们，这可以说是头等大事。

Being able to index vectors, query them dynamically with a query language, that's, like, number one.

但更近期的进展是，作为补充或者说另一种新方法，我们正在尝试的Redis创建者Salvatore开发的向量集合。

But move more recently, you know, as an accompaniment to that or like a different approach, a new approach that we're experimenting with, Salvatore, the creator of Redis, worked on vector sets.

这是一种核心数据结构，与集合等并列，让你能实现类似于当前查询引擎的功能。

And that's a core data structure that sits alongside things like sets and lets you do you know, similar things to what you can do with the query engine right now.

关于向量搜索方面的支持，Redis在向量导入方面具体支持哪些功能？

Terms of some of the support around like vector search, what is supported in terms of getting those vectors actually into Redis?

比如，这部分工作主要是由我负责吗？像是需要在Redis外部完成向量导入的管道工作，然后Redis只作为索引和检索的终端？

Like, am I mostly doing that work, like the kind of pipeline work that I would need to get those vectors in outside of Redis and then Redis ends up being the landing point for indexing and allowing me to retrieve.

还是说Redis会承担部分管道工作？

Or is there other things where Redis kind of owns part of that pipeline?

答案是肯定的，在当前Redis架构中，这部分主要属于客户端的工作范畴。

So the answer is yes, It is mostly a client side concern in our in Redis' current architecture.

如果你想将向量数据存入Redis，那么你需要自己生成嵌入向量，然后它会如你所说存入Redis。

If you want to put something into Redis as a vector, you know, then you're gonna be generating the embedding yourself, and and it's landing in Redis, as you said.

我们今年还推出了一款新产品叫LangCache。

We also have a new product this year called LangCache.

我记得它目前处于私有预览阶段。

It's in private preview, I believe.

它就像是基于Redis的一个更高层抽象，用于我们所说的语义缓存。

It's like a slightly higher level abstraction over using Redis for what we call, like, semantic caching.

我们确实有计划尝试在这个产品流程中集成嵌入模型，你只需把数据发送给这个产品，它会帮你完成这部分工作。

And we do have plans to experiment with including the embedding model, like, within that pipeline of just send things to that product and it will do that part for you.

但就核心Redis和我们今天讨论的现有功能而言，这部分工作需要你自己完成。

But core Redis and what we're talking about today as far as what's available, you do it yourself.

这是第一个问题的答案。

So that's the first answer.

我忘记你刚才提到的另一点了。

I forget your other point there.

它主要是一个外部构建管道的着陆区，还是Redis本身具备某些功能，能让我直接在Redis内部构建部分管道，而无需依赖其他第三方工具？

Is it primarily a landing zone where the pipeline is being built externally or are there essentially functionality in Redis that allows me to build some of that pipeline directly within Redis, not having to leverage some other third party tools?

明白了。

Gotcha.

是的。

Yeah.

是的。

Yeah.

那么我想这就是您问题的答案。

Then I think that is the answer to your question.

对吧？

Right?

大部分工作在于构建生成向量的流程，而Redis则帮助您快速存储和检索这些向量。

Most of that stuff you're building to produce the the vectors, and then Redis is helping you to store them and retrieve them quickly.

您提到了语义缓存。

You mentioned semantic caching.

什么是语义缓存？

What is semantic caching?

语义缓存是我们所说的不基于确定性模式（比如必须依赖键）的缓存方式，而这是我们多年来常用的缓存方法。

Semantic caching is what we would call caching based not on a deterministic pattern like a key necessarily, which is how most we all do caching for many years.

对吧？

Right?

而是基于相似性。

And instead on similarity.

因此，输入内容的相似性成为我们从缓存中提取内容的依据。

So the similarity to an input being the the thing that lets us pull something out of the cache.

这对于那些我们已经从大语言模型获得过答案的问题特别有帮助。

And that's really helpful for questions that we have the answer for already from the LLM.

我们经常会遇到完全相同或极其相似的问题。

So we've got the exact same question, very close to it many, many times.

这样我们就不必反复向供应商付费获取相同答案，可以运用语义缓存来解决这个问题。

We don't have to keep paying a vendor to to produce the same answer so we can use some anti caching for that.

对。

Right.

如果我在构建一个代理来解决特定问题，并且使用Redis作为代理的内存服务，那么我是否需要在编写代码和业务逻辑时主动利用Redis来实现某些功能？比如确保不会因为相同问题或任务多次出现而导致令牌开销过大。

If I'm building out an agent to solve some particular problem and I'm using Redis for basically the service kind of the memory for my agent, am I building because we're writing the code and the business logic to leverage Redis for some of the stuff like, let's say I want to make sure that I'm not going and overspending on tokens because the same question has come in multiple times or the same task has come in multiple times.

我可以在构建过程中利用语义缓存来建立这种钩子，还是说存在某种现成框架可以将Redis集成进去，从而省去这些抽象工作？

I can leverage the semantic caching in my essentially you know, building that hook in the rest or is there something where I can hook Redis into, I don't know, existing framework and I, you know, that's kind of abstracted away.

我们付钱让你问这个问题了吗？

Do we pay you to ask this question?

因为这听起来是个绝妙的计划。

Because this feels like a great a great plan.

你不需要自己编写那段代码。

You don't have to write that code yourself.

不过你也可以选择自己写。

You could, though.

现在用Cloud Code来写这个还挺有趣的。

It's it's quite fun to write it now with Cloud Code.

你可以放手让他去做很多事情。

You can just let him go or let it go and do a lot of stuff.

不过，如果你正在使用许多流行的框架来创建代理，比如LangGraph，或者你只是在使用LangChain而甚至没有用到LangGraph，那么我们有一些即插即用的组件。

However, if you're using many of the popular frameworks that exist for creating agents like LangGraph or you're just doing lane chain stuff and not even using LangGraph, then we have drop in components.

其中一些可以通过外部或我应该说独立的代码库获取，比如LangGraph-Redis，这是我们部分开源LangGraph组件的仓库。

And some of those are available through external or I should say separate repositories like LangGraph dash Redis, get some of our like open source LangGraph parts.

但还有一个由我们维护的库。

But there is also a library that we maintain.

我所在的Redis团队维护了一个名为Redis向量库或Redis VL的库，它可以在PyPI上获取。

Team at Redis that I'm on maintains called Redis Vector Library or Redis VL, and that's available on PyPI.

我们在那里有很多即插即用且更具通用性的组件。

We've got a lot of components in there that are drop in and a little bit more general purpose.

所以你可能不一定在使用某个特定框架，或者你有一个由多个框架拼凑而成的系统，你想要消息历史记录或语义哈希对象，想直接嵌入到一个Python项目中。

So you might not necessarily be using a particular framework or you've got a Frankenstein of them and you want message history or a semantic hash object you want to drop into like a Python project.

你可以用那个库来实现这一点。

You can do that with that library.

所以我们为你准备了几种不同的选择。

So we've got a few different options for you.

你认为最终会进入这样一个世界吗？在众多代理框架中，内存将变得更像可插拔组件，比如‘我想用Redis作为我的记忆提供者’。

Do you think that will end up moving into a world with, you know, with the plethora of agent frameworks that are out there where memory will be sort of more of this like pluggable thing where it's like, hey, I want to use Redis as my memory provider.

我只需简单接入，这些框架就能支持它。

I can just like plug that in and these frameworks support it.

几乎像是某种开放的内存标准。

Almost like a some kind of like open standard for memory.

开放的内存标准。

Open standard for memory.

我认为这是个非常有趣的话题，因为我对这个问题没有确切的答案。

I think it's a really interesting topic because I don't have a good answer on that.

不过，如果你看看LangGraph这类框架的运作方式，我想你能大致看出我预期的演变方向。

However, you know, if you look at the way that frameworks like LangGraph work, I think you can see what I would what I would expect to shape up more or less.

对吧？

Right?

类似于LangChain有一个向量存储接口，可以标准化地将向量存储插入链中，你也可以为你的LangGraph代理更换记忆提供者。

So similar to how LangChain has a vector store interface that standardizes just dropping in a vector store into a chain, you can also swap out the memory provider for your LangGraph agent.

我认为这非常合理。

And I think that makes a lot of sense.

根据我使用这些抽象层的经验，我可以告诉你，它并不总是有效，因为所有数据库都有这些略微不同的个性特点和特性。

Having worked with those abstractions, like, I can tell you, like, it doesn't always work, right, because all databases have these slightly different personality quirks and traits.

特别是当你考虑像过滤向量搜索这样的事情时。

So so especially if you think about things like filtering the vector search.

当然，如果是单纯的向量搜索那还好，我们只是在讨论执行相似性搜索。

So of course, like vector search, that's fine, you know, if we're just talking about just do a similarity search.

但当我们讨论执行相似性搜索并包含25个不同的分面搜索点时，事情就开始变得复杂了。

But when we're talking about do a similarity search and include these 25 different faceted search points around that, that's where it starts to be like, okay.

有些数据库根本不支持这个功能，或者某个数据库有特定的查询类型但实现方式不同。

Well, this database doesn't even support that at all, or this one has this particular query type for that, but it's different.

所以它并不总是像理论上那么顺畅。

So it's not always quite as as smooth as it could be.

因此，这正是标准可以发挥重要作用的地方。

So that's where a standard could be useful for sure.

不过说实话，我真正感兴趣的是像Cogni、MEM0这类代理记忆产品和框架。

I guess what I'm really interested in though is just to be, like, totally brutally honest is stuff like Cogni and MEM0 and agent memory, like, products, agent memory frameworks.

我在思考这究竟是什么样的存在？

And thinking about that as, like, a what what is that like?

因为我曾参与过这类系统的开发，这个领域非常有趣——你能将与记忆相关的内容从即插即用的组件中提取出来，集中放置到核心位置。

Because I I've worked on systems like that now, and it's just a really interesting area where you can take you take more of that thing that is related to memory out of the just drop in a component and use something place and put it in somewhere central.

总之，我认为这是个极具创新潜力的领域。

So anyway, it's a really interesting area of innovation, I think.

确实，从很多方面来说，你确实需要一个位于存储层之上的、专为代理设计的抽象层。

Yeah, I mean, in a lot of ways you do need essentially a layer that's above the storage where that's agent specific?

就像拥有查询引擎还不够，还需要某种专为代理设计的记忆引擎——它能理解代理特有的摘要压缩需求，这些功能通常超出了传统数据库的支持范围。

Kind of like you have a query engine, but you need some sort of, I don't know, memory engine for agents that understand the summarization compaction needs of an agent that go above and beyond those things are typically supported by like a, you know, a conventional database.

没错。

Yeah.

确实如此。

Absolutely.

所以我认为目前的情况是，而且我们可能会看到的是，代理框架将会尝试在这方面开辟新天地。

And so I think where that falls currently and and maybe what we'll probably see is agent frameworks are gonna try to carve that out, I think.

对吧？

Right?

你可以看到LangGraph已经在通过LangMem尝试这样做，其中存储某种程度上是一个可替换的组件。

You you can see LangGraph already trying to do that with LangMem where this, you know, storage is sort of a swappable component.

然后围绕管理所有这些记忆内容的智能和工程，以及其认知系统方面，更像是框架工作的一部分，或者说它承担并试图完成的任务。

And then the intelligence and the engineering around managing all of that memory stuff and the cognitive system aspect of it is more like part of the framework's job or the job that it's taking on and trying to do.

但这确实是个大工程。

But it is a big job.

现在实际参与这项工作后，发现工作量相当大。

Having now worked on that, it's quite a lot.

而且我认为你看看我之前提到的这些产品，就会发现为什么它是一个独立于代理运作的完整系统——代理运作通常更偏向持久化执行或工作流执行。

And I think you look at these products that I mentioned before, and, I mean, you can see why it's it's a whole, like, system separate from the workings of the agent, which tends to be more like durable execution or workflow execution.

所以这件事本身比听起来要复杂得多。

So which itself is more complicated than it sounds to.

是的。

Yeah.

是的。

Yeah.

不过至少可以依赖，我不知道，大约十年左右的工程积累，这些主题已经投入了大量研究。

Although there is, you know, you can rely on at least, I don't know, a decade or so of of engineering that's, you know, been poured into some of those topics.

没错，完全同意。

Yeah, absolutely.

关于长期记忆，是否存在不同类别的思考方式？

In terms of like long term memory, is there different sort of classes of how we think about long term memory?

不仅仅是'这是我要跟踪的数据'，你是否认为需要将这些数据分门别类，以便在智能体工作过程中进行差异化管理和处理？

It's not just, you know, here's the data I want to keep track of, but do you think about those as being in sort of different buckets that you need to be able to manage and treat differently as you know agents progress through their work?

是的，完全正确。

Yeah, absolutely.

我认为如果你仔细想想，不管出于什么原因，当我测试一个智能体及其记忆功能时，我特别喜欢用苹果来举例。

I think if you think about for whatever reason, when I'm testing out an agent and its memory, particularly, I use like apples.

我真的很喜欢苹果，我想。

I I really like apples, I guess.

所以我经常和智能体讨论苹果。

So I'm constantly talking to agents about apples.

每个人都有自己的怪癖，但我觉得用苹果举例是个有趣的切入点。

Everybody has their own weird thing that they do, but I think the apples thing is like an interesting one.

所以我可以告诉智能体我喜欢苹果。

So I can tell an agent that I like apples.

对吧？

Right?

这只是一个事实。

And that's just a fact.

我确实在某个时刻告诉过它我喜欢苹果，但你可以把这看作是关于我的一个事实。

I did tell it at some point that I liked apples, but you could look at it as a fact about me.

事实上，如果你要考察这个关于我的事实是否随时间稳定，你会发现它相当稳定。

In fact, if you were to look at it as whether or not it's stable over time about me in particular, you would find it's pretty stable.

这可能只是一个普遍事实。

It's probably just a general fact.

根据一些论文的分类方式，我喜欢苹果可能属于语义记忆的事实类型。

It might be a semantic fact that I like apples in the words of some of the papers that that break this down into different, like, types of memory.

而如果你和我妻子谈论我和苹果，她会告诉你，'嗯，他确实喜欢苹果'。

Whereas, you know, if you were talking to my wife about me and apples, she would tell you, like, well, he likes apples.

对吧？

Right?

但具体是这周的哪种苹果？

But which type of apple this week?

因为我偏好的苹果品种每周都在变。

Because it changes every week, which is the apple that I prefer.

这种事实就更像与时间或时效性紧密相关的事实。

And that is more like a fact that is very tightly bound to time or duration.

所以，没错，上周我又喜欢上了蜜脆苹果。

So, yeah, last week I did like Honeycrisp again.

这周我更倾向于宇宙脆苹果。

This week it's more about Cosmic Crisp.

你知道，我需要苹果带点酸味，这更像是那种情景记忆。

You know, I need a little bit more tartness in the apple, and that's more like what you would consider like an episodic memory.

或者如果我们再次将这些不同的事实分类，可以将其归为一种有时间限制的记忆类型。

Or if we again, if we were to break these different facts you could store down into types, that could be one type, a type of memory that is time bound.

时间限制这个方面非常重要，因为当代理去检索时——就像我说的，我们实际上是在讨论上下文工程的过程——通过我们的工程过程和运行时部分，我们最终为LLM提供了合适的上下文，以便给应用程序的用户或代理一个像样的响应。

And the time bound aspect is really important because when the agent goes and retrieves you know, we're like I said, we're we're really talking about this process of context engineering where by the end of the process of our engineering and the runtime portion of it, we arrive at the right context for the LLM to give the user of the application or the agent a decent response.

因此我们思考如何达成那个结果。

And so we think about how to get to that outcome.

我们如何才能让代理——比如我让它去买菜什么的——出去买到正确的苹果？

How do we get to the outcome that the agent that I'm asking it to buy my groceries or whatever is gonna go out and buy the right apple?

我可不想它买蜜脆苹果。

I don't want it to buy Honeycrisp.

它需要知道我这周想要宇宙脆苹果，而不需要我每次都去告诉它，因为那样就失去了自主性的价值。

It needs to know that I want Cosmic Crisp this week without me having to go in and tell it every single time because that erases the value of autonomy.

所以它需要存储我喜欢宇宙脆苹果这一事实以及时间信息，这样当它检索信息构建上下文时，可以按时间排序并叠加最近可能的情景记忆。

So it needs to store the fact that I like Cosmic Crisp apples with the time so that when it retrieves stuff to build that context, it can order them by time and overlay the most recent facts that it has that are episodic perhaps.

我想大多数人会说，什么？

Now most people, I think, would say, well, what?

等等。

Well, wait.

情景记忆到底是什么？

What is episodic exactly?

我认为你也可以从另一个角度看待情景记忆，比如说去年夏天我去了奥卡斯岛。

And I think you could also look at episodic in a different way, which is to say, you know, last summer I visited Orcas Orcas Island.

去年夏天也是一个有时间界限的事实。

Last summer is also a time bound fact.

我去了奥卡斯岛。

I visited Orcas Island.

所以它们其实非常相似。

So they kinda are very similar.

因为第一个例子唯一的区别就是我们没有存储时间。

Because really the only difference with the first one is we just didn't store the time.

而且它非常笼统。

And it's really general.

这其实不太实用。

It's like not that useful.

对吧？

Right?

总之，这些其实是我对程序性记忆（另一种记忆类型）的一些犀利见解。

So anyway, those are something I have actually a kind of spicy take on procedural memory, which is another type of memory.

我们可以单独讨论那个问题，但这是我的第一反应。

We could talk about that separately, but that's that's my first response.

是的。

Yeah.

那么，在建模这类内容时，如果需要一个代理来追踪这些事件的发生时间，我是否必须像设计数据库模式那样，先考虑记录时间戳，然后可能还需要加入某种知识随时间衰减的机制？这样就不会向安德鲁提起六年前他早已不关心且无关紧要的事情。

Well, in terms of what goes into like modeling this stuff, though, with an agent, like if I need to keep track of when these types of things happen, do I have to basically go through the process of modeling this like a schema where it's like, Okay, well, need to think of like I need to track the timestamps and then I might need to factor in some sort of, I don't know, decay scenario on this knowledge over time so that I'm not, you know, telling Andrew about something that happened six years ago that he no longer cares about and is no longer relevant.

本质上，如何让代理能够综合考虑所有这些不同因素？

Like how does essentially do inform the agent to be able to be able to take into account all these different things?

是的，完全正确。

Yeah, absolutely.

我刚才记得你说过，我们在工作流和持久执行方面已经积累了几十年的相关知识。

So I I remember just a moment ago, you were like, well, but we have, you know, with workflows and durable execution stuff, we have all these decades of knowledge about how to do it.

关于AI技术，我最欣赏的一点是，几乎所有问题在某种程度上都可以归结为我们拥有数十年经验的领域。

What I love about AI stuff is like pretty much every problem in some way, almost every problem boils down to something that is something we have decades of of experience with.

具体到这个问题，上下文工程和检索本质上都属于信息检索范畴，意味着我们在这方面拥有极其丰富的经验，正是针对这类问题的经验。

So in particular, this one, the fact that context engineering and retrieval are all really a form of information retrieval means that we have tons of experience with this problem, exactly this problem.

长期以来，我们一直在将内容存入搜索引擎并尝试提取，力求获取最相关的信息。

So we we've been putting things into search engines and trying to pull them out and to pull out the most relevant things for a long time.

而且这种方法已经存在很长时间了。

And this is one that's, you know, that's been around.