(图源:项目仓库)
给 AI Agent 做长期记忆,主流做法绕不开向量库:把文本切块、过一遍嵌入模型、存进向量数据库、建索引,检索时算近似相似度,再重排。memanto 想绕开这一整套。
它给自己的定位是「AI Agent 喜欢的记忆」,核心主张是一句话:
可查询,而不是被注入(Queryable, not injectable)。
意思是,大多数记忆工具是「被动基础设施」——把一段静态记忆塞进上下文,有用,但本质是被动的。memanto 想做的是一个「主动的记忆智能体」:你按相关性去查它,而不是把一坨记忆硬塞进提示词。MIT 协议,主要用 Python 写成,目前 1.3k 星、版本 v0.2.4。
三个动作:remember / recall / answer
memanto 把记忆收敛成三个原语,比常见的「写入 + 检索」多了一个 answer:
# 记住一条,带类型memanto remember "用户偏好简洁的回答" --type preference# 按相关性召回,可按类型过滤memanto recall "用户的沟通风格" --type preference# 直接基于记忆回答(对记忆做 RAG)memanto answer "这个用户喜欢什么风格?"answer 是它和别家不太一样的地方:不只把记忆捞出来给你,还能直接基于记忆生成一个有依据的回答。
记忆是有类型的,内置 13 类:instruction、fact、decision、goal、commitment、preference、relationship、context、event、learning、observation、artifact、error。它还支持按时间查——比如「截至某天」「某天之后变化过的」:
memanto recall "deadline" --as-of "2024-01-15" --changed-since "2024-01-01"这对应它想补的几个「记忆缺口」:静态注入、没有时间衰减、缺来源出处、记忆扁平没结构、不做冲突检测、有索引延迟。
核心差异:不用向量库,写进去就能搜
memanto 最不一样的地方在底层:它不走"向量数据库"那一套,而是建在一个叫 Moorcheh 的「信息论语义引擎」上。
先看传统向量检索是怎么干的:文本过一遍嵌入模型变成向量 → 存进向量库、建一套近似索引(HNSW 这类)→ 查询时算余弦相似度、找最近邻 → 再重排。中间得等建索引,返回的还是"近似"结果。
Moorcheh 把后半段整个换掉了。它仍然会用到 embedding,但不靠"在向量空间里量几何距离",而是用信息论的方式去压缩和打分,核心是三步:
- • MIB(最大信息量二值化):把高维浮点向量压成紧凑的二进制——按"信息量、熵"来压,而不是按几何坐标压。
- • EDM(信息论距离):不算余弦相似度,而是看一条记忆"能多大程度降低当前问题的不确定性"来评分。比的不再是"离得近不近",而是"对回答这个问题有多大信息增益"。
- • ITS(信息论分数):给出一个 0 到 1、一致可比、还能解释的相关性分。
这么一换,带来两个直接结果:写入即可搜——没有单独的建索引步骤,存进去当下就能被检索到;以及确定性的精确召回——不是向量库那种近似最近邻,同样的输入给同样的结果。官方称延迟压在 90 毫秒以内。
官方把这件事概括成一句:
没有向量数据库,没有单独的索引管线——写入即可搜索。
它的架构
memanto 自己更像是夹在你的 Agent 和 Moorcheh 引擎之间的一层。官方架构图分三块:
(图源:项目仓库)
- • 左边·你的 Agent 环境:IDE 集成、各种 Agent CLI、自定义 Agent、本地 Web 面板——都是发起方。
- • 中间·memanto 本体:一个网关(CLI 引擎 + FastAPI 服务)加一组共享服务——remember / recall / answer、冲突解决、每日摘要、会话与鉴权、记忆同步、工具连接。
- • 右边·Moorcheh 引擎:真正干检索的地方,提供零索引的语义数据库、为 Agent 优化的 RAG、以及对 LLM 的原生访问。
所以 memanto 干的是「记忆管理 + 编排」,底层检索全部交给 Moorcheh。
它的成绩
memanto 公布的 benchmark:LongMemEval 89.8 分、LoCoMo 87.1 分,并称在这些标准评测上超过了 Mem0、Zep、Letta。
这里要提醒一句:这是 memanto 自己公布的对比,而且各家评测的口径、版本、测试条件并不统一——跨项目直接比数字并不严谨。比如 Mem0 在自家评测里报的 LongMemEval 是 94.8,和这里的口径就不是一回事。看个方向即可,别当成定论。
怎么用
一条命令装好,然后选本地还是云:
pip install memantomemanto # 选 On-Prem(Docker,全本地)或 Cloud(免费 API key)- • On-Prem:要 Docker,所有数据留在本地,不需要账号。
- • Cloud:去 console.moorcheh.ai 拿免费 key,每月送 10 万次操作额度。
接 Agent 也是一条命令,官方列了 14 个以上:Claude Code、Cursor、Codex、Windsurf、Cline、Continue、Goose、GitHub Copilot、Gemini CLI 等:
memanto connect claude-code另外它有 TypeScript SDK,也能 memanto serve 起一个 REST API。
几条注记
- • 强绑定 Moorcheh。memanto 的检索能力全部来自 Moorcheh 这个信息论引擎——虽然有免费的本地 Docker 版,但这是它自研的核心,不是某个开放标准;选它等于接受这一层。
- • 核心引擎闭源,可验证的细节有限。MIB / EDM / ITS 的名字和思路官方给了(见论文 arXiv 2604.22085),但 Moorcheh 是自研闭源,目前第三方复现和独立评测都还少,到底多好得自己上手验。
- • benchmark 是自报的。上面那组分数来自 memanto 自己,跨项目比较要谨慎。
- • 还很早。v0.2、1.3k 星,迭代快但成熟度有限,尝鲜可以,上生产要做好跟版准备。
它在记忆赛道里站哪
把最近这几个 Agent 记忆方案放一起看,差异其实就两个问题。
一是记忆存在哪、给谁看。 一类存在引擎里,是黑盒,你看不懂、只能查(Mem0、memanto);一类存成文件,是白盒,你能打开看、能手改(ReMe、TencentDB Agent Memory)。
二是检索靠什么。 Mem0 靠向量加 embedding,ReMe 靠双链加混合检索,TencentDB 靠文件加数据库分层下钻,memanto 则换成了不用向量的信息论引擎。
放成一张表:
| 项目 | 记忆存哪 | 检索靠什么 | 最大不同 |
|---|---|---|---|
| Mem0 | 引擎(向量库) | 向量 + BM25 + 实体 | 最流行、生态全、有托管云 |
| memanto | 引擎(Moorcheh) | 信息论,不用向量 | 写入即搜、结果精确 |
| ReMe | 文件(Markdown) | 双链 + BM25 + embedding | 可读可改,还会自己整理 |
| TencentDB | 文件 + 数据库 | 分层下钻 | 省 token、100% 可追溯到原文 |
memanto 和 Mem0 其实是一类——都是把记忆塞进一个引擎里、按需查询,而不是落成你能翻看的文件。它在这一类里的特别之处,是把「向量」这个几乎算行业标配的东西整个换掉了。
写在最后
memanto 给 Agent 记忆提了个不一样的思路——不堆历史、不靠向量,换一个号称写入即可搜、结果精确的信息论引擎。思路新,代价是把检索这层整个押在了一个自研引擎上;值不值,要看 Moorcheh 在真实场景里扛不扛得住。
MIT 协议,1.3k 星。仓库地址:github.com/moorcheh-ai/memanto。
近期文章
阿里开源 ReMe:像写双链笔记一样给 AI Agent 做长期记忆
腾讯开源 Agent 记忆方案:不堆历史、不暴力摘要、Token 最高省 61%
写 HTML 就能渲染视频:HeyGen 开源 hyperframes,专为 AI Agent 而生
配音 + 语音输入还在分开付费?全本地开源的 Voicebox 全包了,一分钱不花
开源 4.8 万星 BMAD-METHOD:把分析师、PM、架构师……打造成一支 AI 敏捷团队
(Source: project repository)
For long-term memory in AI Agents, the mainstream approach can't avoid vector databases: chunk text, run it through an embedding model, store it in a vector database, build an index, compute approximate similarity at retrieval time, then rerank. Memanto wants to bypass this entire pipeline.
Its positioning is "memory that AI Agents will love," with a core claim in one sentence:
Queryable, not injectable.
In other words, most memory tools are "passive infrastructure"—stuffing a chunk of static memory into context is useful, but essentially passive. Memanto aims to be an "active memory agent": you query it by relevance instead of cramming a blob of memory into a prompt. MIT licensed, primarily written in Python, currently 1.3k stars, version v0.2.4.
Three operations: remember / recall / answer
Memanto condenses memory into three primitives, adding one more than the common "write + retrieve" pair: answer.
The answer operation is what sets it apart from others: it doesn't just retrieve memories for you, but can directly generate a grounded answer based on them.
Memories are typed, with 13 built-in categories: instruction, fact, decision, goal, commitment, preference, relationship, context, event, learning, observation, artifact, error. It also supports time-based queries—e.g., "up to a certain date" or "changed after a certain date":
This addresses several "memory gaps" it aims to fill: static injection, no time decay, lack of provenance, flat unstructured memory, no conflict detection, and indexing latency.
Key difference: no vector database, searchable immediately after writing
What makes Memanto most different is its underlying layer: it doesn't go the "vector database" route, but is built on a "semantic information theory engine" called Moorcheh.
First look at how traditional vector retrieval works: text passes through an embedding model to become a vector → stored in a vector database with an approximate index built (like HNSW) → at query time compute cosine similarity, find nearest neighbors → then re-rank. In the process, you have to wait for index building, and the results returned are still "approximate."
Moorcheh replaces the second half entirely. It still uses embeddings, but doesn't rely on "measuring geometric distance in vector space." Instead, it compresses and scores using information theory, in three steps:
• MIB (Maximal Information Binarization): compresses high-dimensional floating-point vectors into compact binaries—compressed by "information content, entropy," not by geometric coordinates.
• EDM (Information-Theoretic Distance): doesn't compute cosine similarity, but scores by how much a memory can "reduce the uncertainty of the current question." What's compared is no longer "how close in distance" but "how much information gain for answering the question."
• ITS (Information-Theoretic Score): produces a comparable, explainable relevance score from 0 to 1.
This swap brings two direct results: searchable at write time—with no separate index-building step, data can be retrieved as soon as it's stored; and deterministic exact recall—not approximate nearest-neighbor like vector databases, same input always yields the same result. The official claim is latency under 90ms.
The official summarizes this as:
No vector database, no separate index pipeline—searchable at write time.
Its architecture
Memanto itself is more like a layer between your Agent and the Moorcheh engine. The official architecture diagram has three parts:
(Source: project repository)
• Left · Your Agent environment: IDE integration, various Agent CLIs, custom Agents, local web panel—all initiators.
• Center · Memanto itself: a gateway (CLI engine + FastAPI service) plus a set of shared services—remember / recall / answer, conflict resolution, daily summaries, session and auth, memory sync, tool connections.
• Right · Moorcheh engine: where retrieval actually happens, providing index-free semantic database, Agent-optimized RAG, and native access to LLMs.
So Memanto handles "memory management + orchestration," while all underlying retrieval is delegated to Moorcheh.
Its performance
Memanto's published benchmarks: LongMemEval 89.8, LoCoMo 87.1, and claims it surpasses Mem0, Zep, and Letta on these standard evaluations.
A note here: these are Memanto's self-reported comparisons, and the evaluation criteria, versions, and test conditions across projects are not uniform—directly comparing numbers across projects isn't rigorous. For example, Mem0 reports LongMemEval at 94.8 in its own evaluation, which uses a different methodology. Take it as a directional signal, not a settled conclusion.
How to use it
Install with one command, then choose local or cloud:
• On-Prem: requires Docker, all data stays local, no account needed.
• Cloud: get a free key at console.moorcheh.ai, with 100k operations per month included.
Connecting an Agent is also one command; the official list covers 14+ options: Claude Code, Cursor, Codex, Windsurf, Cline, Continue, Goose, GitHub Copilot, Gemini CLI, etc.:
It also has a TypeScript SDK, and you can also spin up a REST API with `memanto serve`.
Some notes
• Tightly coupled with Moorcheh. Memanto's retrieval capabilities all come from Moorcheh, this information-theory engine—while there's a free local Docker version, this is its proprietary core, not an open standard; choosing it means accepting this dependency.
• Core engine is closed-source with limited verifiable details. The names and ideas of MIB / EDM / ITS were provided by the official (see paper arXiv 2604.22085), but Moorcheh is self-developed and closed-source. Third-party reproductions and independent evaluations are currently scarce—how good it really is, you'll need to verify yourself.
• Benchmarks are self-reported. The scores mentioned above come from Memanto itself; cross-project comparisons should be treated cautiously.
• Still early. v0.2, 1.3k stars—fast iteration but limited maturity. Fine for experimentation; prepare for version churn if moving to production.
Where it stands in the memory赛道
Looking at recent Agent memory solutions together, the differences boil down to two questions.
Where is memory stored and who can see it. One category stores it in an engine—a black box you can't inspect, only query (Mem0, Memanto); another stores it as files—a white box you can open and manually edit (ReMe, TencentDB Agent Memory).
What powers retrieval. Mem0 relies on vectors plus embeddings, ReMe on dual graphs plus hybrid retrieval, TencentDB on files with a database layer-by-layer drill-down, while Memanto switches to an information-theory engine that doesn't use vectors.
Putting it in a table:
Memanto and Mem0 are actually in the same category—both shove memory into an engine for on-demand querying rather than saving it as browsable files. What makes it distinctive within that category is replacing "vectors," nearly an industry staple, entirely.
Final thoughts
Memanto offers a different approach to Agent memory—no history stacking, no reliance on vectors, but swapping in an information-theory engine claimed to be searchable at write time with exact results. The idea is novel; the trade-off is betting the entire retrieval layer on a self-developed engine. Whether it's worth it depends on whether Moorcheh can hold up in real-world scenarios.
MIT license, 1.3k stars. Repository: github.com/moorcheh-ai/memanto.
Recent articles
Alibaba opensources ReMe: like writing bi-directional notes, do long-term memory for AI Agents
Tencent opensources Agent memory solution: no history stacking, no brute-force summarization, saves up to 61% in tokens
Render video with HTML: HeyGen opensources Hyperframes, built specifically for AI Agents
Dubbing and voice input still separately paid? Fully local open-source Voicebox covers it all, for free
Open-source 48k-star BMAD-METHOD: forge analysts, PMs, architects… into an AI agile team


