Memanto MCP

MCP搜索检索

提供方 moorcheh-ai

搜索检索 未标注 OAuth 授权 社区 / 第三方 Claude DesktopClaudeCursorVS Code
查看接入方式

MEMANTO is a memory agent. It remembers, recalls, and answers - so your agents can achieve long-term goals and avoid confusion.

一句话选型结论

按资料字段整理

Memanto MCP 属于搜索检索类 MCP 服务器,传输方式未标注,OAuth 授权,可直接接入 Claude Desktop、Claude、Cursor 等,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类搜索检索 传输方式未标注 鉴权OAuth 授权 部署方式未标注
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

搜索检索
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

memory ai agents long term memory rag llm memory agent memory

支持客户端

适用场景

memoryai agentslong term memory

安装与配置

未标注 OAuth 授权
上游未给出传输方式
pip install memanto-mcp\r

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    按官方文档确认运行环境(常见为 Node.js 或 Python),装好后再执行安装命令。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
联网搜索取证

让模型查最新资料并给出出处。

资料聚合

把一个主题的网页、文档集中抓回来整理。

情报与竞品检索

按关键词持续检索行业动态和竞品信息。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude Desktop、Claude、Cursor,换客户端不用重新研究配置。

先想清楚的地方

  • 使用前要准备好OAuth 授权对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在搜索检索场景里让模型直接调用外部能力的人。
  • 已经在用 Claude Desktop、Claude 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Memanto MCP当前 未标注 未标注 未标注 有 未标注
Brave Search 433812ff 2 未标注 未标注 无 2026-05-17
Sequentialthinking 1 SSE · 服务端推送 远程部署 有 2026-05-18
Baidu Netdisk 未标注 未标注 未标注 无 2026-05-17
ragflow 未标注 stdio · 本地进程 本地部署 有 2026-04-11
mindsdb (430e18) 未标注 未标注 未标注 有 2026-05-17

服务器档案

搜索检索
字段来自项目仓库与公开索引,中文说明由本站标注
提供方moorcheh-ai上游标注的维护方 moorcheh-ai
分类搜索检索本站按上游分类展示
连接方式未标注上游未给出传输方式
鉴权方式OAuth 授权远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · Cross-platform本地安装时用到的包标识与运行时
部署类型未标注上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

14.8 KB
来自项目仓库与上游目录的原文,未做删改

Memanto is a Memory Agent; a companion agent that manages the memories of your other agents:

what to keep, what conflicts, what expires, and who needs to know.

English · Español · 简体中文 · 日本語```bash
pip install memanto
bash npm install @moorcheh-ai/memantobash
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```bash
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.```bash

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.```bash
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/.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:```yaml
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.```bash
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.


⭐ Star the repo if Memanto is managing your fleet's memory

It's the signal that tells us to keep building this in the open, under MIT, with nothing held back.


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.


Full CLI reference

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````bash
memanto remember "User prefers concise answers" --type preference
memanto recall "user communication style" --type preference


Complete reference: CLI User Guide

Install options — fully local vs. free cloud

**Fully local. No account, no API key, nothing leaves your machine:**```bash
pip install memanto
memanto           # choose "On-Prem" — guides through Docker + Ollama setup

Requires Docker.

Free cloud. No card, ~60 seconds:```bash
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`

Architecture

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:**

SDKs & REST API

**Python** — the `memanto` package ships an in-process client; no server to start:```python
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.bibtex @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: support@moorcheh.ai · @moorcheh_ai


MIT License

常见问题

7 问
答案由本站依据条目字段整理,不引用上游原文
Memanto MCP 怎么安装?

在客户端按下面的安装命令接入:pip install memanto-mcp\r。装完在客户端配置里引用同一个包或端点。

Memanto MCP 怎么在 Claude Desktop、Claude、Cursor 里配置?

它的传输方式未标注,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Memanto MCP 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Memanto MCP 需要 API Key 吗?

资料标注需要OAuth 授权认证,使用前准备好对应凭据,并按最小权限配置。

Memanto MCP 支持哪些客户端?

资料标注支持 Claude Desktop、Claude、Cursor、VS Code、Windsurf、Cline;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

Memanto MCP 能提供哪些能力?

资料显示能力标签包括 memory、ai agents、long term memory、rag、llm memory、agent memory。具体工具清单以官方文档为准。

Memanto MCP 需要什么运行环境?

运行时为 Cross-platform。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 未标注。