memanto

moorcheh-aiMIT活跃维护

给 AI Agent 用的长期记忆系统，支持语义记忆和多 Agent 共享记忆管理，让智能体跨会话记住上下文。

Memory that AI Agents Love!

integrations/mcp/v0.1.5发布于 2026-10-29 16:15 UTC2,362star +2 / 7 天744fork同步于 2026-11-10 23:45 UTC

Agent 记忆长期记忆语义记忆多 Agent 记忆管理

对比 GitHub 官网 agent-memory ai-agents ai-memory ai-memory-system hermes-agent

怎么上手

由 README 提炼，执行前请确认

原文

pip install memanto
memanto
memanto connect claude-code

硬件要求按 README 说明

README 未说明具体显存或 GPU 要求；本地模式通过 Docker + Ollama 运行，无需账号或 API Key，也支持免费云端或自托管。

下载：源码 zip·GitHub Releases（安装包）本站不镜像安装包

项目说明

由 README 自动翻译提炼

没人工点评？写下你的经验

管理多个 AI Agent 记忆的伴生 Agent，决定保留、冲突、过期与通知

给 AI Agent 用的长期记忆系统，支持语义记忆和多 Agent 共享记忆管理，让智能体跨会话记住上下文。

核心能力

从对话流中抽取决策、偏好、事实等持久知识
合并重复记忆，重复观察提升置信度而非新增行
新知识冲突时取代旧记忆并保留历史版本
按策略执行衰减、过期与删除，支持恢复
行动前向 Agent 下发最小相关记忆切片

容易踩的坑

本地模式需先装好 Docker 与 Ollama；云端模式需申请免费 key；未设置策略的 Agent 不会自动过期任何记忆。

内容由模型根据 README 生成，可能不完整或不准确，以官方文档为准。看原文 README

用户点评

登录用户的真实使用记录，可按版本和硬件筛选

共 0 条

还没有人点评。第一个说出真实体验的人最有价值。

README 原文

未翻译

在 GitHub 打开

pip install memanto

npm install @moorcheh-ai/memanto

go get github.com/moorcheh-ai/memanto/sdks/go

Every platform will store your agents' memory. None of them will manage it. Managing it across platforms is against their interest. That is the job of a Memory Agent.

Persistence is solved. Claude, Bedrock, Cursor, and every vector store will happily keep what your agents write. None of them will tell you that two of your agents now believe opposite things about your auth service, that a preference from March has quietly outranked a decision from last week, or that the agent you spun up this morning is about to redo work another one finished and reverted.

Storage is a filing cabinet. Memanto is the chief of staff; it decides what goes in, watches the access, resolves what contradicts, discards what's stale, and briefs each agent before it acts.

It's an agent, not an API

Memanto isn't a library you call. It's a second agent that runs beside your fleet and does six things on its own judgment. Each one is a real behavior with a command behind it, nothing here is a roadmap item.

	What Memanto does	Run it
Observes & extracts	Watches the interaction streams of the agents it serves and pulls durable knowledge out of ephemeral traffic — decisions, preferences, facts, failures — instead of archiving transcripts wholesale.	`memanto remember --from-conversation`
Consolidates	Merges extracted memories into one canonical estate. Duplicates collapse, fragments join, repeated observations strengthen confidence instead of multiplying rows.	`memanto schedule enable`
Reconciles	When new knowledge contradicts old, Memanto supersedes rather than appends — preserving what was believed and when. "What's true now" and "what did we believe then" stay different questions.	`memanto conflicts`
Forgets	Decay, expiry, and deliberate deletion are policies it executes, not cleanup you remember to do. An estate that only grows becomes noise; managed forgetting is what keeps recall sharp at month twelve.	`memanto forget`
Briefs	Before an agent acts, Memanto hands it the minimal relevant slice of the estate. Your agents don't query anything — they get briefed by a colleague.	`memanto agent bootstrap`
Moves knowledge	Through the Open Knowledge Format, the estate crosses frameworks and vendors — so a fleet spanning Claude Code, Cursor, and your own stack shares one memory instead of five silos.	`memanto memory export --okf`

And it does this while you're asleep. memanto schedule enable and the loop runs daily: new memories curated, duplicates merged across agents, contradictions flagged for your review. You come back to a fleet that knows more than it did yesterday, without having sorted anything yourself.

60 seconds to a managed fleet

pip install memanto
memanto                            # "On-Prem" (Docker, no account) or "Cloud" (free key)
memanto connect claude-code        # also: cursor, codex, windsurf, cline, goose, copilot…

Your agents now share one managed estate. No code changes, no wrapper, no rewrite of your agent loop.

# backend-agent learns something on Monday
memanto remember "Auth migrated to JWT — session cookies deprecated" --type decision

# review-agent, which never saw that session, knows it on Friday
memanto recall "how does auth work"
memanto answer  "why did we drop session cookies?"     # grounded, no extra API key

# what did the fleet believe last Tuesday? what changed since the release?
memanto recall "deployment policy" --as-of 2026-08-05
memanto recall "deployment policy" --changed-since v2.1

macOS, Linux, Windows. memanto ui opens a local dashboard over the whole estate — browse it, search it, audit it.

Own your agentic memory

This is the part that matters in two years, and it's the part every platform-native memory feature is designed to prevent.

Your estate is a file. memanto memory export --okf gives you the Open Knowledge Format — plain Markdown, readable, diffable, committable, greppable. Not a proprietary dump you can technically request. The actual working format.

It moves. memanto migrate imports from Mem0, Letta, Supermemory, Zep, Hindsight, or any OKF bundle. The same command works in reverse. OKF is an open interchange format any framework or vendor can implement — including ours' competitors, deliberately.

It runs on your machine. Local Docker + Ollama, no account, no API key, nothing leaves your infrastructure. Or free cloud, or your own hosting. memanto config backend switches between them in one command, and the estate comes with you.

MIT. No open-core tier waiting to gate the useful half. No feature flags, no seat limits, no rug pull.

There is no lock-in because there is nothing to lock.

Security & sovereignty

Nothing leaves your machine in on-prem mode. Docker + Ollama, no account, no outbound calls. The full loop — extraction, consolidation, reconciliation, briefing — runs locally.

Scoped by default. Each agent gets its own namespace. Your production-ops agent doesn't read your scratch experiments; you provision exactly what each one should know and nothing more.

Every belief is traceable. Confidence score, source, provenance, and timestamp. When an agent acts on something, you can walk back to where that belief entered the fleet and when — which is the difference between an auditable estate and a black box.

Forgetting is a decision you make, not a side effect. A memory is active or expired — nothing else. It becomes expired only because a policy you wrote says so, and it carries the date and the rule name that did it. Expired memories still recall, clearly labelled, and memanto memory restore puts one back. Deleting is a separate, explicit act.

Memory that expires on your terms

Every memory is active until a policy retires it. Expiry is stamped, auditable, and reversible — the content survives, and the memory keeps showing up in recall marked [EXPIRED] with the reason it aged out.

memanto policy list-preset          # conservative / balanced / aggressive
memanto policy apply-preset balanced  # shows it in full, then asks
memanto policy apply --dry-run      # exactly what would expire, per rule
memanto policy apply                # shows the policy + matches, then confirms

Policies live in ~/.memanto/policies/<agent>.yaml and have two halves — a per-type retention table for broad strokes, and named rules for everything sharper. The first matching rule wins, so a rule can also pin a memory that the table would otherwise expire:

retention:
  context: 7d
  event: 30d
  preference: never          # durable user truths don't age out
rules:
  - name: pinned
    match: {tags: [pinned]}
    expire_after: never      # an explicit pin beats the table
  - name: low-confidence-guesses
    match: {provenance: [inferred], confidence_below: 0.5}
    expire_after: 14d
purge_expired_after: never   # optional hard delete, off by default

Recall shows both states side by side; narrow with --active or --expired. Point-in-time recall is unaffected — --as-of still reconstructs what was true then, including memories that have expired since.

memanto memory expire mem-123       # retire one by hand
memanto memory restore mem-123      # and put it back

The nightly job (memanto schedule enable) runs the sweep for you. An agent with no policy set never expires anything.

Unlike memory storage

	Memory storage	Memanto
What it is	A database with an SDK — write, embed, retrieve	An agent with judgment over your fleet's memory
Core behavior	Persist	Curate, reconcile, consolidate, forget, brief
Who decides what's kept	You, in application code	Memanto, on policy you set once
When two agents disagree	Last write wins, silently	Both versioned, surfaced for review
Forgetting	A `DELETE` you remember to run	A first-class policy that runs on schedule
Scope	One app, one stack, one vendor's walls	A fleet, across stacks and vendors
Your data	Exportable in theory	The working format is portable Markdown

Storage substrates sit beneath Memanto — vector stores, filesystems, and platform-native memory features are all backends it manages. Their commoditization is good for you: it makes the substrate free and leaves the management to something that's actually good at it.

Developer experience

One pip install. No vector store to provision, no embedding pipeline, no reranker, no schema migration, no backend to babysit. The retrieval engine ships in the box.

Works with what you already run. memanto connect claude-code — same for Cursor, Codex, Windsurf, Cline, Continue, Goose, Copilot, and more. One command each.

Searchable the moment it's written. No extraction pass at write time, no graph to rebuild, no indexing queue. remember returns and every agent in the fleet can already recall it.

Typed, not soup. 13 memory categories — instruction, fact, decision, goal, preference, relationship, and more — so recall is filterable instead of one undifferentiated blob.

A dashboard, not a log file. memanto ui for the whole estate. memanto daily-summary for a readable digest of what changed across your agents. memanto status for registered agents, sessions, and health.

Capability	Commands	What it does
System status	`memanto status`	Environment, configuration, server health, active session, registered agents.
Local REST API + web UI	`memanto serve`, `memanto ui`	Run the REST API locally and open an interactive browser UI.
Agent lifecycle	`memanto agent ...`	Create/list/delete agents, activate sessions, run `agent bootstrap`.
Memory capture at scale	`memanto remember`	Single memories, batch JSON, or `--from-conversation` to extract from chat logs.
Editing & deletion	`memanto edit`, `memanto forget`	Update fields on a memory, or permanently delete a bad one.
File ingestion	`memanto upload`	Bring .pdf, .docx, .xlsx, .json, .txt, .csv, .md into an agent's namespace.
Advanced recall	`memanto recall`	Standard search plus temporal queries (`--as-of`, `--changed-since`) with filters.
Grounded answers	`memanto answer`	Generate answers from retrieved memory context.
Daily intelligence	`memanto daily-summary`, `memanto conflicts`	Summaries, contradiction detection, interactive resolution.
Sessions & automation	`memanto session ...`, `memanto schedule ...`	Inspect sessions, enable scheduled daily runs.
Estate export & sync	`memanto memory export`, `memanto memory sync`	Export structured Markdown, sync `MEMORY.md` into projects. `--okf` for a portable OKF bundle.
Import & migration	`memanto migrate`	Import from Mem0, Letta, Supermemory, Zep, Hindsight, or an OKF bundle.
Configuration	`memanto config show`	API key status, active agent/session, server settings, schedule time.
Fleet integration	`memanto connect ...`	Claude Code, Codex, Cursor, Windsurf, Antigravity, Gemini CLI, Cline, Continue, OpenCode, Goose, Roo, GitHub Copilot, Augment.

Memory types: instruction, fact, decision, goal, commitment, preference, relationship, context, event, learning, observation, artifact, error

memanto remember "User prefers concise answers" --type preference
memanto recall "user communication style" --type preference

Complete reference: CLI User Guide

Fully local. No account, no API key, nothing leaves your machine:

pip install memanto
memanto           # choose "On-Prem" — guides through Docker + Ollama setup

Requires Docker.

Free cloud. No card, ~60 seconds:

pip install memanto
memanto           # choose "Cloud" — paste your free API key

Free key at console.moorcheh.ai/api-keys — 100K free operations.

Switch any time: memanto config backend

Recall is powered by an information-theoretic semantic engine that ships in the box — as a local Docker container or as a free cloud service. The memanto CLI manages either for you. Storage substrates beneath it are pluggable; Memanto is the agent above them.

On-prem:

Python — the memanto package ships an in-process client; no server to start:

from memanto import Memanto

memanto = Memanto(agent_id="my-agent")   # creates the agent on first use
memanto.remember("Alex prefers oat milk.", type="preference")
memanto.recall("what does Alex drink?")
memanto.answer("Does Alex drink dairy?")

Reference: docs.memanto.ai/sdk/python.

TypeScript / Node.js — @moorcheh-ai/memanto boots a local Memanto server via uvx and exposes an ergonomic client (remember / recall / answer).

Go — github.com/moorcheh-ai/memanto/sdks/go connects to a running Memanto server or starts one via uvx.

REST API — start with memanto serve. Endpoint reference at docs.memanto.ai/api and http://localhost:8000/docs while running.

Watch it work


Recall is more than search — 6:20	Setup & demo
Local dashboard tour	Docs →

Research

Memanto: Typed Semantic Memory with Information-Theoretic Retrieval for Long-Horizon Agents

On public recall benchmarks we report 89.8% on LongMemEval and 87.1% on LoCoMo. Datasets and harness are open at huggingface.co/moorcheh — run them yourself.

A caveat we'd rather say out loud: cross-project scores on these benchmarks are not comparable. Reader model, judge model, judge prompt, and retrieval budget each move results by several points, and no two published runs share a configuration. Treat every number in this category — including ours — as directional. What a Memory Agent should eventually be measured on isn't recall at all, but estate quality over time: contradiction rate, staleness, and precision at month six.

@misc{abtahi2026memantotypedsemanticmemory,
      title={Memanto: Typed Semantic Memory with Information-Theoretic Retrieval for Long-Horizon Agents},
      author={Seyed Moein Abtahi and Rasa Rahnema and Hetkumar Patel and Neel Patel and Majid Fekri and Tara Khani},
      year={2026},
      eprint={2604.22085},
      archivePrefix={arXiv},
      primaryClass={cs.AI},
      url={https://arxiv.org/abs/2604.22085},
}

Community

Questions: [email protected] · @moorcheh_ai

怎么上手

项目说明

核心能力

容易踩的坑

最近发版

Release Notes for memanto-mcp v0.1.5

New Features & Improvements

Tests

Full Changelog

Release Notes for v0.2.31

Breaking Changes

New Features

Improvements

Release Notes for claudecode-memanto v0.1.2

New Features & Improvements

Removed

Tests

Full Changelog

Release Notes for v0.2.30

Breaking Changes

New Features

Release Notes for memanto-mcp v0.1.4

Breaking Changes / Validation

New Features & Schema Improvements

Prompt Hardening & Server Instructions

Registry & Packaging

Tests

Full Changelog

用户点评

README 原文

It's an agent, not an API

60 seconds to a managed fleet

Own your agentic memory

Security & sovereignty

Memory that expires on your terms

Unlike memory storage

Developer experience

Watch it work

Research

Community

相关项目