Universal Memory

MCP文档知识

提供方 未标注

文档知识 stdio · 本地进程 未标注 社区 / 第三方 Claude DesktopClaudeCursorVS Code
查看接入方式

一个与供应商无关的AI智能体认知持久层。通过跨会话传输上下文、偏好和历史记录,消除“重复税”。配备自动适应引擎,同步全局指令以确保操作一致性,并优化任何LLM或多智能体工作流中的令牌使用。

一句话选型结论

按资料字段整理

Universal Memory 属于文档知识类 MCP 服务器,stdio · 本地进程,鉴权方式未标注,可直接接入 Claude Desktop、Claude、Cursor 等,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类文档知识 传输方式stdio · 本地进程 鉴权未标注 部署方式本地部署
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

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

能力标签

支持客户端

适用场景

记忆

安装与配置

stdio · 本地进程 未标注
客户端在本机拉起子进程,数据不出本机
uvx

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

  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 Node.js 等运行时,再按安装命令拉取依赖。

  2. 2
    安装服务

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

  3. 3
    写入客户端配置

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

  4. 4
    验证是否可用

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

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
文档检索问答

在你的文档库里按问题找答案。

知识库读写

把新资料写进知识库,随用随取。

内容整理

把零散资料归纳成结构化笔记。

选择建议

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

值得选的地方

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

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

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

不太适合

  • 完全不想在本地装环境的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Universal Memory当前 未标注 stdio · 本地进程 本地部署 有 未标注
dify 未标注 stdio · 本地进程 本地部署 有 2026-04-11
open-webui 未标注 stdio · 本地进程 本地部署 有 2026-04-11
JeecgBoot 未标注 stdio · 本地进程 本地部署 有 2026-04-11
Cherry Studio 未标注 未标注 未标注 无 2026-05-17
mempalace 未标注 stdio · 本地进程 本地部署 有 2026-04-11

服务器档案

文档知识
字段来自项目仓库与公开索引,中文说明由本站标注
提供方未标注上游标注的维护方 未标注
分类文档知识本站按上游分类展示
连接方式stdio · 本地进程客户端在本机拉起子进程,数据不出本机
鉴权方式未标注远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · 未标注本地安装时用到的包标识与运行时
部署类型本地部署上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

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

Universal Memory (UMem)

Website | Documentation

A vendor-agnostic cognitive persistence layer for AI agents. Eliminate the "repetition tax" by transporting your context, preferences, guidelines, and history seamlessly across sessions, IDEs, and LLM models.

To see the core idea visually, check out the Excalidraw design or the proposal structure:

Diagram Breakdown

  • Short-Term Memory (Ephemeral): Project-specific (folder-level) memories. A simple summary of recent changes, pending tasks, and project or task-level constraints.
  • Agents Behaviours: Comports the user's expected agent behaviors. Instead of requesting the same settings in every session, the agent understands the user by their traits, thoughts, and any context key to enhancing the overall experience. This encompasses:
    • Long-Term Memory
    • Short-Term Memory
    • User Preferences
  • Skill Creator: Encapsulates understanding of specific workflows. When a user explains a task pattern multiple times, the system translates it into structured, reusable agent skills.
  • Unified Instruction File (AGENTS.md): The shared persistence endpoint consumed by compatible local agent instances (e.g., Agent A, Agent B, Agent C).

The Problem: The "Repetition Tax"

Every time you open a new session in Claude Code, start a new chat in Cursor, spin up a terminal with OpenCode, or invoke a local AI assistant, you pay a steep cognitive tax:
* Re-explaining your stack (e.g., "We use Python 3.12, Typer, and Ruff").
* Repeating coding style preferences (e.g., "Prefer functional design, do not write docstrings unless requested").
* Copy-pasting database connection schemas or module layouts.
* Explaining workflow methodologies (e.g., "We follow Spec-Driven Development (SDD)").

Universal Memory acts as a local persistence layer that automatically connects to your AI runtimes, aligning them to your exact workflow, context, and rules with zero friction.


Key Architectural Concepts

1. Dual-Memory Model

  • Short-Term Memory (Project Scope): Ephemeral, directory-specific context. Tracks what you did 10 minutes ago, current active tasks, and immediate constraints.
  • Universal Memory (Global Scope): Long-lived preferences, style guidelines, tool configurations, and identity.

2. Auto-Adaptation Engine

Instead of copy-pasting instructions, umem monitors your session context and automatically updates active project instruction manifests (AGENTS.md, CLAUDE.md, .cursor/rules/, etc.), enforcing operational consistency across all agents.

3. Model Context Protocol (MCP) Integration

Integrate umem natively with any client supporting the standard MCP (such as Claude Desktop or Cursor). AI agents can programmatically retrieve context, learn new facts, and suggest skills on the fly.

4. Agent Skills Standard

Encapsulates complex, repetitive procedural instructions into formal Agent Skills
(conforming to the agentskills.io standard), complete with
structured directories containing SKILL.md instructions, helper scripts/, and
documentation references/.

Universal Memory keeps one canonical source for each skill. Shared, user-facing project
skills live under umem/skills//SKILL.md; private, operational, and legacy project
skills live under .umem/skills//SKILL.md. Native runtime folders such as
.agents/skills/, .opencode/skills/, and .antigravity/rules/ receive complete
synchronized copies so each agent can consume the same skill in its expected layout.


Installation & Setup

Ensure you have Python 3.12+ installed. You can run or install umem using your preferred package manager.

Try instantly with uvx

You can run umem without installing it permanently:```bash
uvx --from universal-memory umem --help


> [!WARNING]
> `uvx` is best for quick trials. For ongoing use, install Universal Memory as a persistent tool so `umem` is always available and can fully manage long-lived global memories and synced agent skills:
>```bash
> uv tool install universal-memory
> ```

### Install via PyPI```bash
pip install universal-memory

Upgrade Universal Memory

umem update does not upgrade the Python package from PyPI. It performs local, offline
maintenance for the current .umem workspace, such as schema migrations, benchmark refreshes,
and skill synchronization.

To upgrade the installed umem executable, use the package manager that installed it:```bash

If installed with uv tool

uv tool upgrade universal-memory

If installed with pipx

pipx upgrade universal-memory

If installed with pip

python -m pip install --upgrade universal-memory

If running temporarily with uvx

uvx --refresh --from universal-memory umem --version


Confirm the executable you are running:```bash
umem --version
which umem

Upgrading the executable does not silently mutate existing projects. The next time you
work in an initialized project, reconcile it locally:```bash
umem update --check
umem update
umem update --skills
umem connect
umem doctor


You do not need to run `umem init` again. Local maintenance creates snapshots and audit
records before UMEM-owned writes. Existing `.umem/skills/use-universal-memory/` trees and
customized managed files are preserved; if both legacy and canonical Universal Memory
skill roots exist, UMEM stops for an explicit migration decision instead of merging or
deleting either tree.

---

## Quick Start Guide

### 1. Initialize your project

Open your project directory and run:```bash
umem init

Universal Memory detects the agents already used in the workspace, presents one
combined confirmation, configures the best available project integration, and
verifies that the agent can read project context. You do not need to choose an
integration mechanism or know which instruction files it uses.

When a compatible agent needs the portable Agent Skill, UMEM discloses any
network use and external project-scoped copy before confirmation, disables
anonymous installer telemetry, and treats a missing prerequisite or failed
installation as recoverable instead of blocking initialization.

To connect another agent later, run:```bash
umem connect


Explicit runtime selection remains available for automation and unusual setups,
but it is not required for the normal path.

How the portable Tier 2 installation works

UMEM resolves the detected agent's project skill directory from a reviewed catalog
pinned to `skills@1.5.20`, runs one project-scoped installation, and validates the
complete installed skill tree plus a real `umem context` read. It does not install into
a second project and copy the result back.

The command orchestrated by UMEM in `v0.6.2` is equivalent to:```bash
DISABLE_TELEMETRY=1 npx --yes skills@1.5.20 add https://github.com/YanAmorelli/universal-memory/tree/v0.6.2/skills/universal-memory --skill universal-memory --agent pi --copy -y

Here pi is an example; UMEM supplies the detected agent ID. Node.js and npx are
optional prerequisites for this external bridge. When either is unavailable,
initialization remains usable and UMEM reports a managed or manual fallback. Unknown
agent IDs never execute npx.

2. Bootstrap one agent session

At the start of each conversation or agent session, prefer the MCP bootstrap() tool when
it is connected. Otherwise, use the equivalent CLI command:```bash
umem bootstrap --format json


This single call validates the integration and returns project status, active project
context, and the skills catalog. Treat `data.context` as active context, inspect
`data.skills.list`, and request details only for skills relevant to the current task:```bash
umem skills detail <skill-id-or-name> --format json

Run bootstrap only once per conversation or session. It replaces the previous startup
sequence of separate status, context, and skills list calls; it does not perform
installation, synchronization, or configuration.

3. Save your first preferences and facts

Tell umem what to keep in mind. You can target either the project scope (this folder) or the global scope (across all projects):```bash

Save a global preference

umem remember --scope global "Yan is a solutions architect specializing in AI applications"

Save a project-specific constraint

umem remember --scope project "Always use Tomllib instead of PyYAML for configuration files" --tag config


### 4. Retrieve Context
Verify the consolidated context summary generated by combining short-term facts, rules, and global preferences:```bash
umem context --scope project

5. Adopt or create an Agent Skill

If a skill already exists, choose the safest adoption path first. Use adopt for an
existing .umem/skills/ directory; use import for native runtime directories
such as .agents/skills/ and sync it back out to configured runtimes:```bash
umem skills adopt .umem/skills/review-protocol --scope project
umem skills import .agents/skills/review-protocol --scope project --sync
umem skills detail review-protocol


If you are starting from scratch, draft and publish it without native side effects:```bash
umem skills draft create \
  --name "Review Protocol" \
  --description "Reusable review workflow" \
  --trigger "when reviewing code"
umem skills draft validate review-protocol
umem skills publish review-protocol --format summary

For a one-step workflow, create the canonical skill. It is canonical-only by default;
request sync explicitly when native runtime targets should be written:```bash
umem skills create \
--name "Review Protocol" \
--description "Reusable review workflow" \
--trigger "when reviewing code" \
--format summary
umem skills sync review-protocol --check-gitignore --format summary


After editing `.umem/skills/review-protocol/SKILL.md`, refresh one runtime skill with:```bash
umem skills sync review-protocol

6. Check status and health```bash

umem status


---

## Host Integration & Support Matrix

UMEM deliberately separates native ownership from portable compatibility:

| Tier | Contract | Guarantee |
| --- | --- | --- |
| **Tier 1 — Native/Managed** | Maintained host adapter, native setup and repeatable validation | UMEM owns and tests the documented integration. |
| **Tier 2 — Directed CLI** | `AGENTS.md` or the official Agent Skill directs a shell-capable agent to the UMEM CLI | UMEM validates portable instructions, CLI access, and context reading, but not every host-specific behavior. |
| **Tier 3 — Unmanaged MCP** | The user manually connects MCP to a host without a programmed workflow | UMEM validates MCP availability only; agent behavior is not guaranteed. |

The maintained and named integration surfaces are:

| Runtime / Host | Support Tier | Config / Instructions Target |
| --- | --- | --- |
| **Claude Code** | Tier 1 — Native/Managed | `CLAUDE.md`, `.claude/skills/`, `.claude/settings.json` |
| **OpenCode** | Tier 1 — Native/Managed | `AGENTS.md`, `.opencode/skills/`, `.opencode/opencode.jsonc` |
| **Codex (OpenAI)** | Tier 1 — Native/Managed | `AGENTS.md`, `.agents/skills/`, `.codex/config.toml` |
| **Cursor** | Tier 2 — Directed CLI | `.cursor/rules/universal-memory.mdc` |
| **Antigravity** | Tier 2 — Directed CLI | `.antigravity/rules/universal-memory.md` |
| **Pi, Gemini CLI, GitHub Copilot, Cline, Zed, and other reviewed Agent Skills hosts** | Tier 2 — Directed CLI | Project skill directory pinned to the `skills@1.5.20` catalog |
| **Windsurf** | Tier 2 — Frozen legacy adapter | `.windsurf/skills/universal-memory/` |
| **Unmodeled MCP host** | Tier 3 — Unmanaged MCP | User-managed MCP configuration |

An agent appearing in the external `skills` catalog does not make it Tier 1. Tier 1 is
intentionally small and requires a maintained adapter, release evidence, and repeatable
host-specific validation. See the Getting Started guide
for legacy-project behavior and the portable installation flow.

---

## Running as a Model Context Protocol (MCP) Server

AI agents can interact directly with your memory over the Model Context Protocol.
Manual MCP configuration for a host without a programmed UMEM workflow is Tier 3:
tool availability is validated, but instruction loading and agent behavior are not guaranteed.

### One-off Launch Command```bash
uvx --from universal-memory umem-mcp

Persistent Install Launch Command```bash

umem-mcp


### Bootstrap Once Per Session

When the MCP server is connected, agents should call `bootstrap()` once at the beginning
of the conversation or session. It is semantically equivalent to
`umem bootstrap --format json`: both return status, active project context, and the skills
catalog, and both preserve the same fail-fast error behavior. Skill details remain separate
and should be requested only for selected relevant skills.

### Example Config: Claude Desktop (`claude_desktop_config.json`)
Use the `uvx` form when Universal Memory is not installed as a persistent tool:```json
{
  "mcpServers": {
    "universal-memory": {
      "command": "uvx",
      "args": [
        "--from",
        "universal-memory",
        "umem-mcp"
      ]
    }
  }
}

If you installed Universal Memory with uv tool install universal-memory or pipx install universal-memory, use the stable entrypoint:```json
{
"mcpServers": {
"universal-memory": {
"command": "umem-mcp",
"args": []
}
}
}


Troubleshoot startup with:```bash
uvx --from universal-memory umem doctor
uvx --from universal-memory umem-mcp --help

For GUI-launched MCP hosts, use the absolute path to uvx if the host does not inherit
your shell PATH.


Safety & Guardrails

  • API Secret Scanner: umem passes all incoming facts through a passive scanner to block API keys, tokens, or credentials from being stored in your persistent cognitive base.
  • Snapshots & Rollbacks: Every automated update to your config files (AGENTS.md, CLAUDE.md) is preceded by a snapshot backup. You can rollback anytime:```bash
    # View audit logs
    umem audit list --scope project

    Revert last automated modification

    umem rollback --scope project
    `` * **Skill Drift Protection:**umem skills syncdetects managed native drift and keeps local changes by default. Use--drift-decision overwriteonly when you intentionally want canonical UMEM content to replace the managed native copy. * **External Bridge Boundary:** Tier 2 installation throughnpx skills` is an
    explicitly confirmed external mutation. UMEM disables anonymous installer telemetry,
    constrains the target to the current project, and validates the complete result, but
    labels the write as externally executed rather than claiming UMEM snapshot ownership.


Managing Agent Skills

You can draft, create, adopt, import, validate, maintain, and sync specialized behaviors:```bash

List all active skills

umem skills list

Inspect one skill

umem skills detail review-protocol

Draft, validate, and publish without native runtime writes

umem skills draft create --name "Review Protocol" --description "Reusable review workflow"
umem skills draft validate review-protocol
umem skills publish review-protocol

Create a new canonical skill and explicitly sync native targets

umem skills create --name "Review Protocol" --description "Reusable review workflow" --sync

Adopt existing canonical work

umem skills adopt .umem/skills/review-protocol --scope project

Import an existing native skill and distribute complete runtime copies

umem skills import .agents/skills/review-protocol --scope project --sync

Validate and maintain canonical skills

umem skills validate review-protocol
umem skills canonical update review-protocol --file .umem/skills/review-protocol/SKILL.md
umem skills rename review-protocol --slug review-checklist
umem skills cleanup review-checklist --targets --format summary
umem skills cleanup review-checklist --targets --apply
umem skills repair --remove-orphan-targets --format summary

Synchronize one canonical skill into active native runtime folders

umem skills sync review-protocol --check-gitignore --format summary

Synchronize all active canonical skills during maintenance

umem update --skills

Track and review recurring workflow candidates

umem skills track --name "Review Protocol" --description "Recurring review workflow"
umem skills recommend --scope project
umem skills propose <latent-skill-id> --decision yes
umem skills promote <recommendation-id> --yes
umem skills generate <latent-skill-id> --yes
```


License

Distributed under the Apache License 2.0. See LICENSE and NOTICE for more information.

常见问题

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

在客户端按下面的安装命令接入:uvx。装完在客户端配置里引用同一个包或端点。

Universal Memory 怎么在 Claude Desktop、Claude、Cursor 里配置?

它的传输方式是stdio · 本地进程,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Universal Memory 收费吗?

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

Universal Memory 需要 API Key 吗?

资料没有标注鉴权方式,是否需要密钥取决于服务本身,接入前按官方文档确认。

Universal Memory 支持哪些客户端?

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

Universal Memory 能提供哪些能力?

资料显示能力标签包括 记忆。具体工具清单以官方文档为准。

Universal Memory 需要什么运行环境?

属于本地进程,需要在本机装好运行环境。

Universal Memory 是本地还是远程?

它是本地进程(stdio),由客户端在本机拉起。传输方式为stdio · 本地进程。

热门专题

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

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