MemoryGuard

MCP文档知识

提供方 未标注

文档知识 未标注 未标注 社区 / 第三方 ClaudeCursorVS CodeCodex

本地优先的MCP内存治理,适用于编码代理,具备共享规则、去重、审计、回滚和令牌洞察功能。

一句话选型结论

按资料字段整理

MemoryGuard 属于文档知识类 MCP 服务器,传输方式未标注,鉴权方式未标注,可直接接入 Claude、Cursor、VS Code 等,没有现成安装命令,需按官方文档接入。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

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

工具与能力

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

能力标签

支持客户端

适用场景

记忆

安装与配置

未标注 未标注
上游未给出传输方式
  1. 1
    准备运行环境

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

  2. 2
    安装服务

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

  3. 3
    写入客户端配置

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

  4. 4
    验证是否可用

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

典型使用场景

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

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

知识库读写

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

内容整理

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

选择建议

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

值得选的地方

  • 已适配 Claude、Cursor、VS Code,换客户端不用重新研究配置。

先想清楚的地方

  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

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

不太适合

  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
MemoryGuard当前 未标注 未标注 未标注 无 未标注
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

服务器档案

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

详细介绍

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

MemoryGuard

Governed shared memory for coding agents.

Local-first MCP memory with automatic organization, scoped rules, evidence, and rollback.

中文文档

> Let agents write without turning shared memory into an unreviewed pile.
> MemoryGuard organizes each write, preserves the evidence behind changes, and
> keeps governance decisions reversible.
>
> No account. No remote server. No remote telemetry. Local-only usage telemetry
> is optional and stores bounded, privacy-preserving aggregates locally.

Quick start ·
Upgrade ·
Knowledge Library ·
Architecture ·
Supported hosts ·
Privacy and safety

A synthetic governed projection: signals move through memory categories while raw conversation text remains outside the graph.

What's New in v0.7.15

  • Automatic CodeGraph builds: Trusted bootstrap starts a project's first
    build in a background process. Default and per-project switches persist;
    disabling automation preserves the graph. Supported file-write events
    trigger incremental refresh.
  • Clear graph navigation: Switch between a file overview and symbols,
    filter by file, inspect neighboring relations, and use zoom controls.
  • Bounded temporary storage: Ordinary graph queries read SQLite directly
    instead of retaining full-database copies. Validation and installation
    temporary files use the owning project/deployment cache and are cleaned up
    when the operation ends.

See the v0.7.15 release note and
CodeGraph automation details. Reconnect or
restart hosts after upgrading and repairing their provider integration.

Earlier governance improvements

v0.7.13 strengthens mandatory-rule replacement and recovery, improves
audience-aware identity handling, and improves conflict resolution:

  • Safe mandatory-rule replacement: Replacements validate the final
    mandatory package against audience matching, canonical rules, deduplication,
    sensitivity checks, and publication budgets. Equivalent unlocked predecessors
    retire in the same transaction; failed validation rolls back the complete
    update. See the replacement and recovery details.
  • Native Agent/group audience matching: Matching and deduplication no longer
    split the same native audience solely by provider or runtime role. Distinct
    Agent identities remain separate, and project-scoped audiences retain their
    project boundaries. Provider repair uses the verified identity for its target
    provider.
  • Readable, atomic conflict resolution: Conflict views preserve readable
    peer information, and resolution keeps peer groups intact while applying the
    selected changes atomically. Ambiguous conflicts remain unresolved.
  • Cursor Hook protection: Cursor MemoryGuard Hooks now use a 30-second
    timeout, up from 15 seconds, with failClosed: true.

v0.7.14 only corrects release metadata for the GitHub repository rename; it does not change runtime behavior. See the v0.7.14 release note.

See the v0.7.13 release note and
release history.

Earlier release details are kept in the Changelog and
GitHub release records.

Token evidence and demo

Usage events distinguish measured_cached_input from
measured_cache_write_input. measured_cache_coverage.cache_read and
cache_write report complete, partial, or unavailable; measured zero
remains 0, while missing provider data remains None/unavailable.
Character-based estimates remain explicitly labelled
estimated mg_deterministic_unit, never provider tokens.

Run the benchmark only against an authorized local workspace:```powershell
python scripts/benchmark_usage_telemetry.py --workspace . --window-days 7 --sync


Read the benchmark guide for measured,
estimated, derived, and unsupported semantics. Use the demo recording
checklist for a sanitized walkthrough. The
repository's synthetic graph artwork is not a live product capture; it is not
evidence of usage or savings.

## Major V2 refactor in v0.6.0

v0.6.0 was a production data-plane refactor, not a storage-only upgrade:

- **Authoritative V2 domains:** Memory, Rules, Evidence, Content, Runtime, Projection, Assets, CodeGraph, Skills, and System state are separated into explicit SQLite domains with governed boundaries.
- **Explicit cutover:** `V1_ACTIVE → V2_BUILDING → V2_READY → V2_ACTIVE` is fail-closed; V2 never silently falls back to legacy stores or dual-writes after READY/ACTIVE.
- **Lossless migration:** frozen-source preparation uses coherent SQLite online backups, validates source/target evidence, rechecks live-source drift, and preserves V1 data plus migration backups for rollback.
- **Native routing:** MCP, CLI, GUI, and Hook surfaces are classified explicitly; the release closed the 233-surface cutover with 138 implemented routes, 95 retired routes, and zero neutral/blocker routes.
- **Governed intelligence:** Rule lifecycle and RuleMerge, extraction/enrichment, External MCP import, provider control-plane, conversation history, Knowledge Library, and GUI governance all use the V2 evidence and decision paths.
- **Operational evidence:** Reference Audit, per-domain SQLite health, guarded maintenance, rollback evidence, and safe unbound diagnostics are part of readiness and operations.

## Why MemoryGuard

Persistent memory solves storage. It does not solve governance.

When several coding agents write into the same context, records become
duplicated, stale, contradictory, over-broad, or unsafe to reuse. MemoryGuard
sits between coding agents and their shared memory to keep that context usable.

| Without governance | With MemoryGuard |
|---|---|
| Notes accumulate without a canonical state | Writes are classified, deduplicated, superseded, or surfaced as conflicts |
| A correction silently destroys the old value | Evidence and supersede chains preserve what changed and why |
| Tokens and credentials can remain active | Sensitive-looking content is quarantined from active memory |
| Every write needs manual approval | Agents write normally; people review exceptions and outcomes |
| Raw chat logs leak into future context | Conversation history remains a separate, explicitly read evidence archive |

## System architecture```mermaid
%%{init: {"theme":"base","themeVariables":{"background":"#071521","fontFamily":"Arial, sans-serif","fontSize":"14px","primaryTextColor":"#EEF4F8","lineColor":"#557287","edgeLabelBackground":"#071521","clusterBkg":"#0A1A29","clusterBorder":"#27445A"},"flowchart":{"htmlLabels":true,"curve":"basis","nodeSpacing":32,"rankSpacing":48,"padding":14}}}%%
flowchart TB
    Hosts["CODING-AGENT HOSTS<br/>Claude Code · Codex · Cursor · TRAE    "]:::host
    Gateway["LOCAL INTEGRATION<br/>MCP stdio · redirect rules · lifecycle hooks    "]:::gateway

    subgraph Core["GOVERNANCE CORE    "]
        direction LR
        Identity["TRUST<br/>identity · scope    "]:::core
        MemoryAPI["MEMORY<br/>governed I/O    "]:::active
        Rules["RULES<br/>scope · assignment    "]:::rule
        HistoryAPI["HISTORY<br/>search · timeline    "]:::history
        Security["SAFETY<br/>validate · quarantine    "]:::danger

        Identity --> MemoryAPI
        Identity --> Rules
        Identity --> HistoryAPI
        MemoryAPI --> Security
    end

    subgraph Stores["LOCAL GOVERNED STORES    "]
        direction LR
        SharedDB[("V2 DOMAIN STORES<br/>Memory · Rules · Evidence · Content    ")]:::store
        HistoryDB[("HISTORY STORE<br/>isolated conversations    ")]:::historyStore
        AuditDB[("RECOVERY STORE<br/>versions · receipts · backups    ")]:::store
    end

    Bootstrap["BOUNDED CONTEXT BOOTSTRAP<br/>mandatory rule pack · relevant recall    "]:::bootstrap
    Control["HUMAN CONTROL<br/>CLI · desktop governance console    "]:::surface

    Hosts --> Gateway --> Identity
    MemoryAPI --> SharedDB
    Rules --> SharedDB
    HistoryAPI --> HistoryDB
    Security --> AuditDB
    SharedDB --> Bootstrap
    Control --> Identity

    classDef host fill:#12243A,stroke:#38D5C8,color:#EEF4F8,stroke-width:1.4px;
    classDef gateway fill:#0D3338,stroke:#38D5C8,color:#EEF4F8,stroke-width:2.4px;
    classDef core fill:#12243A,stroke:#557287,color:#EEF4F8,stroke-width:1.4px;
    classDef active fill:#0D383A,stroke:#38D5C8,color:#EEF4F8,stroke-width:2px;
    classDef rule fill:#3B2C18,stroke:#F3B562,color:#EEF4F8,stroke-width:1.8px;
    classDef history fill:#102F45,stroke:#73C7F5,color:#EEF4F8,stroke-width:1.8px;
    classDef danger fill:#3A2028,stroke:#EA6A6A,color:#EEF4F8,stroke-width:1.8px;
    classDef bootstrap fill:#EEF4F8,stroke:#38D5C8,color:#071521,stroke-width:2.4px;
    classDef store fill:#0B1624,stroke:#7F96A8,color:#EEF4F8,stroke-width:1.4px;
    classDef historyStore fill:#102436,stroke:#73C7F5,color:#EEF4F8,stroke-width:1.4px;
    classDef surface fill:#EEF4F8,stroke:#38D5C8,color:#071521,stroke-width:2px;

    style Core fill:#081827,stroke:#27445A,stroke-width:1px,color:#EEF4F8
    style Stores fill:#081827,stroke:#27445A,stroke-width:1px,color:#EEF4F8
    linkStyle default stroke:#557287,stroke-width:1.4px;

Quick start

MCP Registry metadata

This package exposes a local stdio MCP server as io.github.MerakOsiris/memoryguard.
Registry metadata is kept in server.json, and the marker above
ships with the PyPI package README. Releases are published through GitHub OIDC
to PyPI and the official MCP Registry. Verify the current package version and
the Registry entry's active/latest state through their live public records.

1. Install```bash

python -m pip install agent-memguard


For the desktop governance console:```bash
python -m pip install "agent-memguard[gui]"

2. Authorize the current project```bash

memoryguard source add .


### 3. Connect or repair your coding agent

Global provider configuration is rebuilt from the real binding in the canonical user data home. The command is idempotent and removes superseded MemoryGuard project-level overrides after a successful global takeover.```bash
# Repair one provider
memoryguard provider repair claude
memoryguard provider repair codex
memoryguard provider repair cursor
memoryguard provider repair trae

# Repair every detected provider
memoryguard provider repair all

Restart the host after installation, then verify the integration:```bash
memoryguard doctor
memoryguard mcp-status
memoryguard hooks status --provider all


Launch the desktop console:```bash
memoryguard gui

memoryguard-gui . remains available for desktop shortcuts. A bare
memoryguard gui always opens the canonical user-level control directory
(default %LOCALAPPDATA%\MemoryGuard on Windows), so running it from a project
or from C:\Windows\System32 cannot silently switch databases.
MEMORYGUARD_WORKSPACE is an explicit operator override; an explicit
memoryguard gui or memoryguard gui --workspace
selects a specific workspace.
It does not remember a previously selected project or open a folder picker.
On Windows, memoryguard gui detaches the native window from the terminal, so
closing PowerShell does not close the GUI.

Provider-specific setup and behavior:

  • Claude Code installation
  • Codex installation
  • Cursor installation

Stable Codex / Router binding

Codex/Router binds MemoryGuard to the stable local Codex program and control
installation. An account profile is an endpoint/alias, not a new memory owner:
switching profiles automatically discovers or repairs the profile and reuses the
verified Agent binding and active group. Request identity remains fail-closed;
this does not share records across machines or with arbitrary accounts.

Upgrade

MemoryGuard currently upgrades through Python's package manager:```bash
python -m pip install --upgrade agent-memguard
memoryguard --version
memoryguard doctor


If you installed the GUI extra, keep it during the upgrade:```bash
python -m pip install --upgrade "agent-memguard[gui]"

There is no package self-update command. The package manager is the
authoritative package-upgrade path; memoryguard upgrade below is the explicit
workspace migration flow, not a package updater.

Upgrade an existing V1 data home

Upgrade the package, then run the verified migration. No workspace, data-home,
apply, or confirmation arguments are required for the normal user-level data
home:```bash
python -m pip install --upgrade agent-memguard
memoryguard --version # confirms installed version
memoryguard upgrade
memoryguard doctor


The command prepares V2, validates the frozen and live source evidence,
migrates Agent/Group control, activates only after all gates pass, and removes
only the backup batch belonging to that successful migration. Re-running it on
`V2_ACTIVE` is idempotent. For a zero-write report, use:```bash
memoryguard upgrade --preview

Advanced explicit workspace/data-home options remain available for operators
managing an isolated installation. A failed gate stays non-active and preserves
its evidence; successful activation does not keep a redundant migration backup.

Existing pre-V2 workspaces: explicit V2 cutover

v0.6.0 never auto-activates an existing workspace. Upgrade the package first,
then use the packaged operator CLI:```bash

Read-only manifest status

memoryguard-v2 status -w .

Build a frozen-source V2 shadow and stop at V2_READY

memoryguard-v2 prepare -w . --apply

Activate only after the prepare result is V2_READY / ready=true

memoryguard-v2 activate -w . --confirm V2_ACTIVE


The prepare step uses coherent SQLite online backups, preserves V1 and
`migration-backups`, and rechecks live-source drift before READY. Activation
performs another fresh drift check before changing the manifest. Do not delete
legacy V1 data or migration backups as part of the upgrade.

## Knowledge Library

The desktop console can turn a selected folder or file set into one governed
local knowledge library. Source files remain where they are; MemoryGuard stores
the searchable index in its user data home instead of copying a runtime
database into every source project. Knowledge metadata never becomes a second
source-body store.

| Capability | Current behavior |
|---|---|
| File/folder ingestion | Add a folder as a book or selected files as documents |
| Structure | Parse documents, preserve chapter/section context, and create traceable chunks |
| Retrieval | Full-text search, optional embeddings, and a layered knowledge graph |
| Natural synchronization | Re-ingest changed files; a partial or failed scan does not silently remove previously indexed content |
| Lifecycle | Move a book to the library trash, restore it, or explicitly purge its recovery snapshot |
| Memory candidates | Preview evidence-backed candidates before accepting them into governed long-term memory |

Open the desktop console and choose **Knowledge Library**. Remote embedding or
model-backed indexing is opt-in and requires explicit authorization; local
full-text retrieval remains available without sending source text to a remote
provider. Background imports, re-ingests, and smart rebuilds have durable task
receipts: retrying the same request reuses its task, while reusing that key for
a different request is rejected. A live task for a different request reports
busy rather than claiming that work was accepted.

### CodeGraph refresh

The first CodeGraph build is an explicit, confirmed full build. After a scope
has been built, each successful trusted file write can trigger an incremental
refresh for that scope, subject to strict source-path and active-binding
validation. Unchanged content hashes are a no-op; deleted files are retired;
the next context receives one bounded `affected` receipt. MemoryGuard does not
run a daemon or watcher for this path and does not infer paths from shell or
free-form text. A projectless MCP caller first builds an already-bound directory
source, then passes its `codegraph_source_id` to select that exact scope for
query, status, update, and graph reads.

### Desktop console surfaces

The GUI has eight visible navigation entries: seven governance pages plus a
separate Token usage-and-savings view:

1. Governance Overview
2. Data Sources & Agents
3. Memory Core
4. CodeGraph
5. Rules & Habits
6. Conversation History
7. Risk Signals & Governance Console
8. Token Usage & Savings (separate from the seven governance pages)

Agent lists use readable program/provider names; the underlying ID remains
available in the detail view. Empty data is shown as an explicit empty state.

## Write and governance lifecycle```mermaid
%%{init: {"theme":"base","themeVariables":{"background":"#071521","fontFamily":"Arial, sans-serif","fontSize":"14px","primaryTextColor":"#EEF4F8","lineColor":"#557287","edgeLabelBackground":"#071521","clusterBkg":"#0A1A29","clusterBorder":"#27445A"},"flowchart":{"htmlLabels":true,"curve":"basis","nodeSpacing":30,"rankSpacing":42,"padding":14}}}%%
flowchart TD
    subgraph Intake["01 · INTAKE    "]
        direction LR
        Write(["Memory write    "]):::entry
        Scope["Resolve identity<br/>scope · audience    "]:::core
        Validate{"Authorized?    "}:::decision
        Reject["Reject<br/>no persistence    "]:::danger
        Write --> Scope --> Validate
        Validate -- NO --> Reject
    end

    subgraph Organize["02 · ORGANIZE    "]
        direction TB
        Secret{"Sensitive?    "}:::decision
        Quarantine["Quarantine<br/>outside active set    "]:::danger
        Compare["Classify · compare<br/>governed records    "]:::active
        Relation{"Relationship    "}:::decision
        New["NEW<br/>create active record    "]:::result
        Duplicate["DUPLICATE<br/>merge provenance    "]:::result
        Correction["CORRECTION<br/>supersede old record    "]:::rule
        Conflict["CONFLICT<br/>preserve both sides    "]:::danger

        Secret -- YES --> Quarantine
        Secret -- NO --> Compare --> Relation
        Relation --> New
        Relation --> Duplicate
        Relation --> Correction
        Relation --> Conflict
    end

    subgraph Govern["03 · GOVERN    "]
        direction LR
        Receipt[("Evidence event<br/>version receipt    ")]:::store
        Review["CLI or desktop review    "]:::surface
        Action["Correct · merge<br/>restore · delete    "]:::rule
        Snapshot["Reversible<br/>snapshot    "]:::active
        Receipt --> Review --> Action --> Snapshot
    end

    Validate -- YES --> Secret
    Quarantine --> Receipt
    New --> Receipt
    Duplicate --> Receipt
    Correction --> Receipt
    Conflict --> Receipt

    classDef entry fill:#EEF4F8,stroke:#38D5C8,color:#071521,stroke-width:2.4px;
    classDef core fill:#12243A,stroke:#557287,color:#EEF4F8,stroke-width:1.5px;
    classDef decision fill:#0D3338,stroke:#38D5C8,color:#EEF4F8,stroke-width:2px;
    classDef active fill:#0D383A,stroke:#38D5C8,color:#EEF4F8,stroke-width:2px;
    classDef result fill:#12243A,stroke:#38D5C8,color:#EEF4F8,stroke-width:1.6px;
    classDef rule fill:#3B2C18,stroke:#F3B562,color:#EEF4F8,stroke-width:1.8px;
    classDef danger fill:#3A2028,stroke:#EA6A6A,color:#EEF4F8,stroke-width:1.8px;
    classDef store fill:#0B1624,stroke:#7F96A8,color:#EEF4F8,stroke-width:1.4px;
    classDef surface fill:#EEF4F8,stroke:#38D5C8,color:#071521,stroke-width:2px;

    style Intake fill:#081827,stroke:#27445A,stroke-width:1px,color:#EEF4F8
    style Organize fill:#081827,stroke:#27445A,stroke-width:1px,color:#EEF4F8
    style Govern fill:#081827,stroke:#27445A,stroke-width:1px,color:#EEF4F8
    linkStyle default stroke:#557287,stroke-width:1.4px;

The console is not an approval queue. Agents keep moving. MemoryGuard records
the outcome and exposes the evidence needed to correct it later.

What you can govern

Signal Governance action
Duplicate or stale memory Inspect the canonical record and supersede chain; restore an earlier version when needed
Conflicting memories Keep both visible until the conflict is resolved deliberately
Secrets, tokens, or credentials Quarantine the record so it cannot enter active shared memory
Incorrect automatic organization Correct, merge, lock, restore, or roll back with evidence
Multiple coding agents Bind agents to one shared group while preserving source identity and scope
Mandatory rules Assign rules to an Agent, project, provider, runtime role, or shared group

Rules and history stay separate

MemoryGuard deliberately keeps governed long-term memory and raw conversation
history on different paths.

Surface Purpose Context behavior
Rules and habits Preferences, procedures, corrections, facts, projects, and scoped mandatory rules Mandatory rules use an independent char/token budget after scope, exclude, conflict, and semantic dedup. Effective count above 20 is a health warning, not a hard block; storage is not capped by count. Sensitive, corrupt, per-item oversize, and aggregate overflow still fail closed with no silent truncation. Ordinary records are recalled when relevant
Conversation history Local raw-evidence archive with owner and shared-group access controls Never enters bootstrap automatically; raw text is read only through explicit history tools
Neuron graph Navigation and governance over memory, rules, projects, agents, and sessions History nodes contain safe metadata and summaries, not raw chat content

History retrieval is progressive: search results, then a bounded timeline, then
an explicitly selected turn or session. Extracting from history creates a
preview first; it does not silently write a long-term memory.```mermaid
%%{init: {"theme":"base","themeVariables":{"background":"#071521","fontFamily":"Arial, sans-serif","fontSize":"14px","primaryTextColor":"#EEF4F8","lineColor":"#557287","edgeLabelBackground":"#071521","clusterBkg":"#0A1A29","clusterBorder":"#27445A"},"flowchart":{"htmlLabels":true,"curve":"basis","nodeSpacing":30,"rankSpacing":42,"padding":14}}}%%
flowchart LR
subgraph HistoryPath["CONVERSATION EVIDENCE    "]
direction TB
Archive[("Raw local history    ")]:::historyStore
Search["Search summaries    "]:::history
Timeline["Bounded timeline    "]:::history
Read["Explicit turn or session    "]:::history
Preview["Evidence-backed<br/>extraction preview&nbsp;&nbsp;&nbsp;&nbsp;"]:::history
Confirm["Explicit acceptance&nbsp;&nbsp;&nbsp;&nbsp;"]:::surface
Isolation["NO AUTOMATIC<br/>BOOTSTRAP PATH&nbsp;&nbsp;&nbsp;&nbsp;"]:::barrier

    Archive --&gt; Search --&gt; Timeline --&gt; Read --&gt; Preview --&gt; Confirm
    Archive -.-&gt; Isolation
end

subgraph GovernedMemory[&quot;GOVERNED LONG-TERM MEMORY&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&quot;]
    direction TB
    Mandatory[&quot;Scoped mandatory rules&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&quot;]:::rule
    Assignments[&quot;Agent · project&lt;br/&gt;role · group scope&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&quot;]:::core
    RulePack[&quot;Mandatory-rule&lt;br/&gt;budget&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&quot;]:::budget
    Ordinary[&quot;Facts · preferences&lt;br/&gt;projects · procedures&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&quot;]:::memory
    Recall[&quot;Task-relevant&lt;br/&gt;recall budget&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&quot;]:::budget
    Context[&quot;BOUNDED CONTEXT PACKET&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&quot;]:::context

    Mandatory --&gt; Assignments --&gt; RulePack --&gt; Context
    Ordinary --&gt; Recall --&gt; Context
end

HistoryPath ==&gt;|GOVERNED WRITE&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;| GovernedMemory

classDef rule fill:#3B2C18,stroke:#F3B562,color:#EEF4F8,stroke-width:1.8px;
classDef core fill:#12243A,stroke:#557287,color:#EEF4F8,stroke-width:1.4px;
classDef memory fill:#0D383A,stroke:#38D5C8,color:#EEF4F8,stroke-width:1.8px;
classDef budget fill:#12243A,stroke:#38D5C8,color:#EEF4F8,stroke-width:1.6px;
classDef context fill:#EEF4F8,stroke:#38D5C8,color:#071521,stroke-width:2.4px;
classDef history fill:#102F45,stroke:#73C7F5,color:#EEF4F8,stroke-width:1.6px;
classDef historyStore fill:#102436,stroke:#73C7F5,color:#EEF4F8,stroke-width:1.6px;
classDef surface fill:#EEF4F8,stroke:#73C7F5,color:#071521,stroke-width:2px;
classDef barrier fill:#3A2028,stroke:#EA6A6A,color:#EEF4F8,stroke-width:2px;

style GovernedMemory fill:#081827,stroke:#27445A,stroke-width:1px,color:#EEF4F8
style HistoryPath fill:#081827,stroke:#27445A,stroke-width:1px,color:#EEF4F8
linkStyle default stroke:#557287,stroke-width:1.4px;

```

Supported hosts

Host Integration Current boundary
Claude Code Global MCP binding, redirect rules, user-level lifecycle Hook Verified takeover path
Codex Global MCP binding, redirect rules, user-level lifecycle Hook Verified takeover path
Cursor Global MCP binding, redirect rules, user-level lifecycle Hook Verified takeover path
TRAE MCP binding and redirect rules No verified Hook seam; reported as a fallback instead of full takeover

Provider status is reported honestly as redirected, observed, operational, or
unsupported. MemoryGuard does not claim it can disable every host's native
memory when the host exposes no reliable integration point.

Architecture

Layer Responsibility
Evidence & Content Authorized sources, immutable evidence, content-addressed blobs/occurrences, source manifests, and conversation archives
Memory & Rules Scoped memory atoms, revisions, bindings, rule definitions, decisions, evidence links, and compensating governance operations
Runtime & Projection Bounded working context, scenario/profile projections, CodeGraph, Assets, and Skills metadata
Cutover & Governance Four-state manifest, native MCP/CLI/GUI/Hook routing, Reference Audit, maintenance, provider adapters, and rollback evidence

V2 uses separate authoritative SQLite domains rather than one shared-memory
database. The runtime reads and writes V2 only after the manifest reaches
V2_ACTIVE; V2_BUILDING and V2_READY never silently fall back or dual-write.
Evidence remains traceable without being treated as automatically trusted memory.

Privacy and safety

  • MemoryGuard runs as a local MCP stdio server.
  • All governed data stays local unless you explicitly authorize a remote model
    or embedding operation. Optional usage telemetry is local-only: its measured
    host token events and deterministic conversion events are stored under
    .memoryguard/usage_telemetry.sqlite; it does not upload data. Token savings
    are estimates based on MemoryGuard deterministic units, not a provider billing
    statement. Hosts without token reporting remain unsupported in the measured
    columns.
  • The Knowledge Library database uses MEMORYGUARD_HOME or the platform user
    data directory, so a selected source folder does not receive its own
    knowledge database.
  • V2 authoritative workspace state is separated under .memoryguard/ into
    explicit Memory, Rules, Evidence, Content, Runtime, Projection, Assets,
    CodeGraph, Skills, and System domains; History, Source, Binding, and Group
    control are V2-native surfaces. Legacy V1 artifacts are preserved as local
    rollback/audit evidence after cutover and are no longer the active V2 runtime
    write path; only memoryguard.migration may read them.
  • Source scanning is read-only by default.
  • Mutating governance paths use validation, explicit scope, provenance, and
    reversible state.
  • Quarantined records stay outside active shared memory.
  • Raw conversation history is never injected into bootstrap automatically.
  • Shared-group history access follows current active membership and does not
    grant deletion rights over another Agent's source.

CLI

The installed memoryguard command exposes these top-level operations:

Command · Purpose
audit [path] · Run a read-only audit and generate a report
open [path] · Open the latest interactive report
explain · Explain evidence and risk for a finding
source · List, add, remove, or preview authorized sources
scan · Scan authorized sources and build the coverage ledger
doctor · Diagnose V2 manifest, domain availability, and native coverage
mcp-status · Inspect V2 MCP/backend health; tenant counts require a bound Agent scope
hooks · Install, inspect, pause, repair, or remove host Hooks
provider · Inspect or repair global provider integrations
storage audit · report · Run read-only V2 Reference Audit and per-domain SQLite health reports
storage sweep · compact · Run guarded V2 maintenance; physical changes require ACTIVE state, lease, generation, and safety proofs
groups · Inspect governed group state
gui [path] · Launch the interactive governance console
desktop · Launch the trusted desktop executor

The old V1 plan, apply, verify, undo, import, and gc workflows may
remain parseable as explicit retired compatibility surfaces, but are not a V1
runtime path. Under V2_ACTIVE they return a stable retired result instead of
writing through a legacy store. Legacy data input is accepted only by the
explicit memoryguard.migration upgrade flow.

Run memoryguard --help or memoryguard --help for the live command
reference.

MCP API

The default MCP discovery surface is intentionally compact. New MCP clients

…(正文过长,页面只展示前面部分,完整内容见仓库)

常见问题

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

资料没有给出安装命令,请到官方仓库或文档按说明接入;这类条目多数是生态应用,或尚未发布可安装包。

MemoryGuard 怎么在 Claude、Cursor、VS Code 里配置?

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

MemoryGuard 收费吗?

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

MemoryGuard 需要 API Key 吗?

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

MemoryGuard 支持哪些客户端?

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

MemoryGuard 能提供哪些能力?

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

热门专题

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

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