Your Memory

MCPAI代理

提供方 Sachit Misra

AI代理 未标注 API Key 社区 / 第三方 Claude

Persistent memory for AI agents, important things stick, forgotten things fade, outdated facts get pruned automatically using the Ebbinghaus forgetting curve.

一句话选型结论

按资料字段整理

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

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

工具与能力

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

能力标签

支持客户端

适用场景

Persistent MemoryMCPAgentic AIRAGClaudeLLM

安装与配置

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

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

  2. 2
    安装服务

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

  3. 3
    写入客户端配置

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

  4. 4
    验证是否可用

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

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
给代理接外部能力

让代理在任务中途调用搜索、数据库等真实工具。

多步任务编排

把一串操作拆成步骤,由代理按顺序执行。

自动化重复流程

把固定流程交给代理跑,减少手工操作。

选择建议

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

值得选的地方

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

先想清楚的地方

  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 使用前要准备好API Key对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

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

不太适合

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

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Your Memory当前 未标注 未标注 未标注 无 2026-05-18
Filesystem 560c4363 13 未标注 本地部署 无 2026-05-17
Server Everything (everything) 11 stdio · 本地进程 本地部署 有 2026-05-17
Time 7365cb6d 2 SSE · 服务端推送 远程部署 有 2026-05-18
Everything Claude Code 未标注 stdio · 本地进程 本地部署 有 2026-05-17
Openmemory 557e1585 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

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

详细介绍

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

YourMemory

Your AI has the memory of a goldfish. Not anymore.

Persistent, self-improving memory for AI agents — built on the science of how humans remember.

▶ Try the live interactive demo · Website · Benchmarks


The problem

Every morning your AI agent treats you like a stranger. Same context re-explained. Same preferences forgotten. Every session starts from zero.

Most "memory" tools bolt a vector database onto an agent and call it done — but that's just storage. It hoards every near-duplicate until retrieval drowns in noise. A goldfish with a bigger bowl.

YourMemory is different: memory that works like a brain, not a database.```mermaid
flowchart LR
A["🧠 You tell your<br/>AI something"] --> B["Extract durable<br/>facts"]
B --> C["Dedup + embed<br/>+ graph-link"]
C --> D[("Memory<br/>store")]
D -->|"related facts pile up"| E["✨ Consolidate<br/>N → 1 summary"]
D -->|"stale + unused"| F["📉 Decay<br/>+ prune"]
D -->|"new session"| G["♻️ Recall<br/>hybrid + graph"]
E --> D
G --> H["🤖 Your agent<br/>picks up where<br/>it left off"]
style D fill:#0a2540,stroke:#19cdff,color:#fff
style E fill:#0c2b3a,stroke:#5eead4,color:#fff
style H fill:#0c2b3a,stroke:#19cdff,color:#fff


---

## ✨ What makes it different

| | Feature | What it does |
|---|---|---|
| 🧠 | **Consolidation** | When enough related facts accumulate, they&#x27;re compressed into one clean summary and the originals are archived. Memory gets **sharper over time, not bloated**. |
| 📉 | **Biological decay** | Every memory ages on an **Ebbinghaus forgetting curve**. Stale, unused facts fade; important and frequently-recalled ones persist. |
| 🔗 | **Entity graph** | Memories link by shared people, places, and concepts — so recall surfaces what you *forgot to ask for*. |
| ♻️ | **Survives context resets** | When the context window compacts, YourMemory hands the working context back — no re-reading files to figure out where you were. |
| 🔒 | **Tamper-evident audit trail** | Every read / write / delete is logged in a **hash-chained** ledger. Alter one record and the chain breaks. |
| 👥 | **Team memory pools** | Role-based shared memory, so a whole team&#x27;s agents draw on the same institutional knowledge — with private memories kept private. |
| 🛡️ | **Data rights built in** | One-command **export** (right to access) and **right-to-forget** (purge), plus SOC 2-aligned controls. |
| 🔌 | **MCP-native &amp; local-first** | Works with Claude, Cursor, Cline, Windsurf, or any MCP client. Runs entirely on your machine — no API key, nothing leaves your system. |

&gt; One command to install. DuckDB by default (zero setup), Postgres + pgvector for teams.

---

## Table of Contents

- 🏆 Benchmarks
- 🚀 Quick Start
- 🧠 How Memory Works
  - Consolidation
  - Decay
  - Hybrid Retrieval
- 🔒 Trust &amp; Audit Trail
- 👥 Team Memory Pools
- 🛡️ Data Rights &amp; Compliance
- 🎛️ Dashboards
- 🔧 MCP Tools
- ⚡ Ask Without an LLM Call
- 🔀 API Proxy — Guaranteed Memory
- 🏗️ Architecture &amp; Stack
- 🩺 Troubleshooting
- 🤝 Contributing

---

## 🏆 Benchmarks

Three external datasets. Every number independently reproducible — benchmark code lives in the repo. Full methodology in BENCHMARKS.md.

### LoCoMo-10 — multi-session conversational memory```mermaid
xychart-beta
    title &quot;Recall@5 · LoCoMo-10 (higher is better)&quot;
    x-axis [&quot;Mem0&quot;, &quot;Zep Cloud&quot;, &quot;Supermemory&quot;, &quot;YourMemory&quot;]
    y-axis &quot;Recall@5 percent&quot; 0 --&gt; 70
    bar [18, 28, 31, 59]

> 2× better recall than Zep Cloud across all 10 samples. *Supermemory and Mem0 exhausted free-tier quotas mid-benchmark; scores computed over the full 1,534 pairs.

LongMemEval-S — 500 questions, ~53 distractor sessions each

The hardest standard benchmark for long-term memory. Each question is buried in ~53 sessions.

Metric Score
Recall@5 (any gold session in top-5) 89.4%
Recall-all@5 (all gold sessions in top-5) 84.8%
nDCG@5 (ranking quality) 87.4%

HotpotQA — 200 multi-hop questions

System BOTH_FOUND@5
YourMemory (vector + BM25 + entity graph) 71.5%
YourMemory (no entity edges) 59.5%

Entity graph edges add +12 pp — they traverse from Fact 1 to Fact 2 even when Fact 2 has low embedding similarity to the query.

Writeup: I built memory decay for AI agents using the Ebbinghaus forgetting curve


🚀 Quick Start

Python 3.11–3.14. No Docker, no database setup. All memory stored locally in ~/.yourmemory/.```bash
pip install yourmemory
yourmemory-register <your-token>
yourmemory-setup


**Get your token:** visit **yourmemoryai.xyz** → enter your email → verify with a 6-digit code → copy your token.

`yourmemory-setup` auto-detects and wires up **Claude Code, Claude Desktop, Cursor, Windsurf, and Cline**, then asks which backend to use:

- **DuckDB** — zero setup, single local file *(default)*
- **Postgres** — shared / production; you provide a `DATABASE_URL` (needs the pgvector extension)

&gt; **Optional — smarter local extraction:** YourMemory works out of the box with built-in heuristics. For higher-quality, fully-local fact extraction, install Ollama and `yourmemory-setup` pulls the model (`qwen2.5:7b`, ~4.7 GB) automatically. Prefer the cloud? Set `YOURMEMORY_EXTRACT_BACKEND=anthropic`.

### Or install from a binary — no Python required

Prefer not to touch pip? Grab the standalone binary for your platform from the latest release:

| Platform | Asset |
|----------|-------|
| macOS (Apple Silicon) | `yourmemory-macos-arm64.tar.gz` |
| macOS (Intel) | `yourmemory-macos-x86_64.tar.gz` |
| Linux (x86-64) | `yourmemory-linux-x86_64.tar.gz` |
| Windows (x86-64) | `yourmemory-windows-x86_64.exe.zip` |
```bash
# macOS / Linux — download, extract, run
tar -xzf yourmemory-macos-arm64.tar.gz
./yourmemory-macos-arm64 register &lt;your-token&gt;
./yourmemory-macos-arm64 setup
./yourmemory-macos-arm64            # start the server

One executable handles every command: register, setup, ask &quot;&quot;, path, and (with no args) starts the server.

Fully self-contained & offline — the binary bundles Python, every dependency, and both ML models (the embedding model + spaCy). Nothing is downloaded on first run. The trade-off is size (~2 GB). Build your own with a single command — ./build-binary.sh — and multi-platform release binaries are produced automatically by the build workflow.


🧠 How Memory Works

YourMemory treats memory as a living system — it grows, consolidates, forgets, and connects, the way a brain does.

Consolidation — N → 1

Most memory tools just keep growing. YourMemory watches for clusters of related facts and, once enough accumulate, compresses them into a single clean summary — archiving the originals (never deleting, so nothing is lost).```mermaid
flowchart LR
subgraph before [Related facts pile up]
A1["Railway uses Nixpacks"]
A2["Railway on Pro plan"]
A3["Railway env vars hold<br/>the Postgres URL"]
A4["Deploys on Railway<br/>with Postgres"]
end
before --> C{"cluster +<br/>LLM summarize"}
C --> S["✨ Summary<br/>Deploys on Railway (Pro,<br/>Nixpacks) with Postgres<br/>via env vars"]
C -.->|"archived, recoverable"| ARC[("archive")]
style S fill:#0a2540,stroke:#5eead4,color:#fff
style C fill:#0c2b3a,stroke:#19cdff,color:#fff


&gt; Real example from one production store: **444 memories → 16 summaries** — same knowledge, a fraction of the noise. Consolidation is **event-driven** (triggered when related memories pile up), not a blind nightly job.

### Decay — the forgetting curve

Memory strength decays exponentially. Importance and recall frequency slow that decay:```
effective_λ  = base_λ × (1 − importance × 0.8)
strength     = clamp(importance × e^(−effective_λ × active_days) × (1 + recall_count × 0.2), 0, 1)

active_days counts only days you were active — vacations don't cause memory loss. Memories below strength 0.05 are pruned automatically. Each category ages at its own rate:

Category Half-life Best for
strategy ~38 days Patterns that worked, architectural decisions
fact ~24 days Preferences, identity, stable knowledge
assumption ~19 days Inferred context, uncertain beliefs
failure ~11 days Errors, wrong approaches, environment-specific issues

Chain-aware pruning: a decayed memory is kept alive if any graph neighbour is still strong — load-bearing context survives even when rarely queried directly.

Hybrid Retrieval — Vector + BM25 + Graph

Recall runs in two rounds so it surfaces both what you asked for and what you forgot to ask for:```mermaid
flowchart LR
Q["query"] --> R1["Vector + BM25<br/>hybrid search"]
R1 --> R2["Graph expansion<br/>(what you forgot to ask)"]
R2 --> S["rank by<br/>similarity × strength"]
S --> OUT["🎯 Ranked memories"]
style OUT fill:#0a2540,stroke:#19cdff,color:#fff


**Subject-aware deduplication** runs before every store — it embeds the subject of each sentence so `&quot;Sachit uses DuckDB&quot;` and `&quot;YourMemory uses DuckDB&quot;` stay separate (different entities), while `&quot;YourMemory uses DuckDB&quot;` and `&quot;YourMemory stores data in DuckDB&quot;` merge (same entity). No hardcoded word lists; generalises to any language.

---

## 🔒 Trust &amp; Audit Trail

Enterprises won&#x27;t let an opaque black box store their data. So every operation — **read, write, update, delete, consolidation** — is appended to a **hash-chained, tamper-evident audit log**.```mermaid
flowchart LR
    E0[&quot;GENESIS&quot;] --&gt; E1
    subgraph E1 [Event 1]
        H1[&quot;row_hash =&lt;br/&gt;sha256(prev + data)&quot;]
    end
    E1 --&gt; E2
    subgraph E2 [Event 2]
        H2[&quot;row_hash =&lt;br/&gt;sha256(#1.hash + data)&quot;]
    end
    E2 --&gt; E3
    subgraph E3 [Event 3]
        H3[&quot;row_hash =&lt;br/&gt;sha256(#2.hash + data)&quot;]
    end
    E3 --&gt; V{&quot;GET /audit/verify&quot;}
    V --&gt;|chain intact| OK[&quot;✅ verified&quot;]
    V --&gt;|any row altered| BAD[&quot;❌ chain breaks&lt;br/&gt;at that row&quot;]
    style OK fill:#0a2540,stroke:#5eead4,color:#fff
    style BAD fill:#3a0c14,stroke:#fb7185,color:#fff

Each row records the timestamp, actor user + agent, action, operation, target memory, source (http vs mcp), and the previous row's hash. Change any historical record and verify_chain() pinpoints exactly where the chain broke.```bash
GET /audit # browse the trail (filter by user / action / operation)
GET /audit/verify # cryptographically verify the chain is untampered
POST /audit/prune # retention-based cleanup (90-day minimum, never lower)


&gt; Audit logging is **fail-open** — it never blocks a memory operation — and read/list events from the dashboard&#x27;s own render loop are excluded, so the trail stays signal, not noise.

---

## 👥 Team Memory Pools

Give a whole team&#x27;s agents one shared brain — without leaking anyone&#x27;s private context. Memories are either **shared** (visible to the pool) or **private** (visible only to their owner).```mermaid
flowchart TB
    P((&quot;🧠 Team Pool&lt;br/&gt;shared memory&quot;))
    A[&quot;Alice&#x27;s agent&quot;] &lt;--&gt;|shared| P
    B[&quot;Bob&#x27;s agent&quot;] &lt;--&gt;|shared| P
    C[&quot;Carol&#x27;s agent&quot;] &lt;--&gt;|shared| P
    A -. private .-&gt; AP[&quot;🔒 Alice-only&quot;]
    B -. private .-&gt; BP[&quot;🔒 Bob-only&quot;]
    style P fill:#0a2540,stroke:#19cdff,color:#fff
    style AP fill:#0c1424,stroke:#5a6b80,color:#8294a8
    style BP fill:#0c1424,stroke:#5a6b80,color:#8294a8

Role-based access is enforced per agent — what one engineer's agent learns, the whole team benefits from instantly; sensitive context stays scoped to its owner.```bash
POST /pools # create a pool
POST /pools/{id}/members # add a member (with role)
POST /pools/{id}/memories # contribute a shared memory
POST /pools/{id}/retrieve # recall across the pool


---

## 🛡️ Data Rights &amp; Compliance

Because memory that stores real data needs the controls to be trusted with it:

| Right | Endpoint | What it does |
|-------|----------|--------------|
| **Access** (DSAR export) | `GET /users/{id}/export` | Full export of everything stored for a user |
| **Erasure** (right to forget) | `DELETE /users/{id}/memories` | One-command purge of a user&#x27;s memories |
| **Portability** | `POST /users/{id}/import` | Re-import a previous export |
| **Recoverability** | `GET /users/{id}/archive` | Retrieve consolidated-away originals |

Combined with the hash-chained audit trail and 90-day retention floor, these map directly onto the controls documented in SECURITY.md (SOC 2-aligned).

---

## 🎛️ Dashboards

Two built-in browser UIs — no extra setup, they start automatically with the server.

### Memory Dashboard — `http://localhost:3033/ui`

A full read/write view with **Memories · Audit · Pools** tabs: stats bar (Strong / Fading / Near-prune), per-agent tabs, memory cards with live strength bars, category filters, the audit trail, and pool management.

### Graph Visualiser — `http://localhost:3033/graph`

An interactive force-directed map of how memories connect — root memory as a bright node, neighbours color-coded by category, edge thickness = connection strength. Drag, zoom, and click any node for full content.```
http://localhost:3033/graph?memoryId=42&amp;userId=alex&amp;depth=2

🔧 MCP Tools

Three tools, called by your AI automatically.

Tool When your AI calls it What it does
recall_memory(query, current_path?) Start of every task Surfaces memories ranked by similarity × decay strength; spatial boost for path-matched memories
store_memory(content, importance, category?, context_paths?) After learning something new Embeds, deduplicates, stores with decay; tags optional file/dir paths
update_memory(id, new_content, importance) When a stored fact is outdated Re-embeds and replaces; logs the change to the audit trail
# Store with spatial context
store_memory(
    &quot;Alex prefers tabs over spaces in Python&quot;,
    importance=0.9, category=&quot;fact&quot;,
    context_paths=[&quot;/projects/backend&quot;],
)

# Next session — spatial boost fires when working in that directory
recall_memory(&quot;Python formatting&quot;, current_path=&quot;/projects/backend&quot;)
# → {&quot;content&quot;: &quot;Alex prefers tabs over spaces in Python&quot;, &quot;strength&quot;: 0.87}

⚡ Ask Without an LLM Call

The only memory system that can answer questions without making any LLM API call:```bash
yourmemory ask "what database does this project use"

→ YourMemory uses DuckDB locally and Postgres in production.

yourmemory ask "how do I fix a kubernetes deployment"

→ Not enough memory context to answer without an LLM.


When memory is strong enough it answers instantly — zero tokens, zero cloud cost, zero latency. When it isn&#x27;t, it declines cleanly rather than hallucinating. Your query never leaves your machine.

---

## 🔀 API Proxy — Guaranteed Memory

MCP tools are called at the AI&#x27;s discretion. The API proxy removes that uncertainty — it intercepts every LLM call, injects relevant memories automatically, and handles `store_memory` / `update_memory` with no model configuration.

Start the server (`yourmemory`), then point your client at `localhost:3033`:```python
from anthropic import Anthropic

client = Anthropic(
    api_key=&quot;sk-ant-...&quot;,
    base_url=&quot;http://localhost:3033/proxy/anthropic&quot;,
    default_headers={&quot;X-YourMemory-User&quot;: &quot;alex&quot;},  # per-user memory
)

# Memory is injected automatically — no other changes needed
response = client.messages.create(
    model=&quot;claude-opus-4-8&quot;,
    max_tokens=1024,
    messages=[{&quot;role&quot;: &quot;user&quot;, &quot;content&quot;: &quot;What database do I use?&quot;}],
)

OpenAI works identically via base_url=&quot;http://localhost:3033/proxy/openai&quot;.


🏗️ Architecture & Stack```mermaid

flowchart LR
C["Your AI client<br/>Claude · Cursor · any MCP"] <--> Y["🧠 YourMemory"]
Y --> M[("Memory<br/>store")]
Y --> A[("Audit<br/>ledger")]
style Y fill:#0a2540,stroke:#19cdff,color:#fff
style M fill:#0c1a2c,stroke:#5eead4,color:#fff
style A fill:#0c1a2c,stroke:#5eead4,color:#fff


| Component | Role |
|-----------|------|
| **DuckDB** | Default vector store — zero setup, native cosine similarity |
| **PostgreSQL + pgvector** | Optional — for teams or large datasets |
| **NetworkX** | Default graph backend (`~/.yourmemory/graph.pkl`) |
| **Neo4j** | Optional graph backend |
| **sentence-transformers** | Local embeddings (`multi-qa-mpnet-base-dot-v1`, 768 dims) |
| **spaCy** | Local NLP for deduplication and entity extraction |
| **APScheduler** | Automatic decay + pruning |

---

## 🩺 Troubleshooting

**Writes hang / time out (DuckDB single-writer lock).** If both the MCP server and the HTTP server run at once, they compete for the DuckDB write lock. Fix:```bash
pkill -f yourmemory 2&gt;/dev/null || true
rm -f ~/.yourmemory/memories.duckdb.wal ~/.yourmemory/memories.duckdb.lock 2&gt;/dev/null || true
# restart your client

Running Claude Desktop (MCP) and Claude Code (hooks) simultaneously? Use SQLite instead — it handles concurrent readers/writers cleanly:
DATABASE_URL=sqlite:///~/.yourmemory/memories.db


🤝 Contributing

PRs welcome — see CONTRIBUTORS.md.

📚 Dataset References

  • LoCoMo — Maharana et al. (2024)
  • LongMemEval — Wu et al. (2024)
  • HotpotQA — Yang et al. (2018)

📄 License

Copyright 2026 Sachit Misra — Licensed under CC-BY-NC-4.0.

Free for personal use, education, academic research, and open-source projects.
Commercial use requires a separate written agreement → mishrasachit1@gmail.com

Give your AI a memory worth keeping.
pip install yourmemory

常见问题

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

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

Your Memory 怎么在 Claude 里配置?

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

Your Memory 收费吗?

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

Your Memory 需要 API Key 吗?

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

Your Memory 支持哪些客户端?

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

Your Memory 能提供哪些能力?

资料显示能力标签包括 RAG、Claude、API密钥。具体工具清单以官方文档为准。

热门专题

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

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