Skip to content
Back to search

YourMemory

Agentic AI memory with Ebbinghaus forgetting curve decay. +16pp better recall than Mem0 on LoCoMo.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/sachitrafa--yourmemory/badge.svg)](/listings/sachitrafa--yourmemory)

HTML

<a href="/listings/sachitrafa--yourmemory"><img src="/api/listings/sachitrafa--yourmemory/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

**Python 3.11–3.14. No Docker, no database setup. All memory stored locally in `~/.yourmemory/`.**

pip install yourmemory
yourmemory-register <your-token>
yourmemory-setup

**Get your token:** visit **[yourmemoryai.xyz](https://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)

> **Optional — smarter local extraction:** YourMemory works out of the box with built-in heuristics. For higher-quality, fully-local fact extraction, install [Ollama](https://ollama.com) 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](https://github.com/sachitrafa/YourMemory/releases/latest):

| 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` |

# macOS / Linux — download, extract, run
tar -xzf yourmemory-macos-arm64.tar.gz
./yourmemory-macos-arm64 register <your-token>
./yourmemory-macos-arm64 setup
./yourmemory-macos-arm64            # start the server

One executable handles every command: `register`, `setup`, `ask "<question>"`, `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](.github/workflows/build-binary.yml).

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 459 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <!-- mcp-name: io.github.sachitrafa/yourmemory -->
  2. <div align="center">
  3. <img src="logo.svg.png" alt="YourMemory" width="110" /><br>
  4. <h1>YourMemory</h1>
  5. ### Your AI has the memory of a goldfish. Not anymore.
  6. **Persistent, self-improving memory for AI agents — built on the science of how humans remember.**
  7. [![PyPI](https://img.shields.io/pypi/v/yourmemory?color=blue&logo=pypi&logoColor=white)](https://pypi.org/project/yourmemory/)
  8. [![PyPI Downloads](https://img.shields.io/pypi/dm/yourmemory?color=brightgreen)](https://pypi.org/project/yourmemory/)
  9. [![Python](https://img.shields.io/pypi/pyversions/yourmemory)](https://pypi.org/project/yourmemory/)
  10. [![License: CC BY-NC 4.0](https://img.shields.io/badge/license-CC%20BY--NC%204.0-lightgrey)](https://creativecommons.org/licenses/by-nc/4.0/)
  11. [![GitHub Stars](https://img.shields.io/github/stars/sachitrafa/YourMemory?style=social)](https://github.com/sachitrafa/YourMemory)
  12. [![LoCoMo Recall@5](https://img.shields.io/badge/LoCoMo%20Recall%405-59%25-brightgreen)](BENCHMARKS.md)
  13. [![LongMemEval Recall@5](https://img.shields.io/badge/LongMemEval%20Recall%405-89.4%25-brightgreen)](BENCHMARKS.md)
  14. [![HotpotQA BOTH@5](https://img.shields.io/badge/HotpotQA%20BOTH%405-71.5%25-brightgreen)](BENCHMARKS.md)
  15. [![MCP Native](https://img.shields.io/badge/MCP-native-19cdff)](https://modelcontextprotocol.io)
  16. <br>
  17. **[▶ Try the live interactive demo](https://sachitrafa.github.io/YourMemory/marketing/interactive.html)** · **[Website](https://yourmemoryai.xyz)** · **[Benchmarks](BENCHMARKS.md)**
  18. </div>
  19. ---
  20. ## The problem
  21. Every morning your AI agent treats you like a stranger. Same context re-explained. Same preferences forgotten. Every session starts from zero.
  22. 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.
  23. **YourMemory is different: memory that works like a brain, not a database.**
  24. ```mermaid
  25. flowchart LR
  26. A["🧠 You tell your<br/>AI something"] --> B["Extract durable<br/>facts"]
  27. B --> C["Dedup + embed<br/>+ graph-link"]
  28. C --> D[("Memory<br/>store")]
  29. D -->|"related facts pile up"| E["✨ Consolidate<br/>N → 1 summary"]
  30. D -->|"stale + unused"| F["📉 Decay<br/>+ prune"]
  31. D -->|"new session"| G["♻️ Recall<br/>hybrid + graph"]
  32. E --> D
  33. G --> H["🤖 Your agent<br/>picks up where<br/>it left off"]
  34. style D fill:#0a2540,stroke:#19cdff,color:#fff
  35. style E fill:#0c2b3a,stroke:#5eead4,color:#fff
  36. style H fill:#0c2b3a,stroke:#19cdff,color:#fff
  37. ```
  38. ---
  39. ## ✨ What makes it different
  40. | | Feature | What it does |
  41. |---|---|---|
  42. | 🧠 | **Consolidation** | When enough related facts accumulate, they're compressed into one clean summary and the originals are archived. Memory gets **sharper over time, not bloated**. |
  43. | 📉 | **Biological decay** | Every memory ages on an **Ebbinghaus forgetting curve**. Stale, unused facts fade; important and frequently-recalled ones persist. |
  44. | 🔗 | **Entity graph** | Memories link by shared people, places, and concepts — so recall surfaces what you *forgot to ask for*. |
  45. | ♻️ | **Survives context resets** | When the context window compacts, YourMemory hands the working context back — no re-reading files to figure out where you were. |
  46. | 🔒 | **Tamper-evident audit trail** | Every read / write / delete is logged in a **hash-chained** ledger. Alter one record and the chain breaks. |
  47. | 👥 | **Team memory pools** | Role-based shared memory, so a whole team's agents draw on the same institutional knowledge — with private memories kept private. |
  48. | 🛡️ | **Data rights built in** | One-command **export** (right to access) and **right-to-forget** (purge), plus SOC 2-aligned controls. |
  49. | 🔌 | **MCP-native & local-first** | Works with Claude, Cursor, Cline, Windsurf, or any MCP client. Runs entirely on your machine — no API key, nothing leaves your system. |
  50. > One command to install. DuckDB by default (zero setup), Postgres + pgvector for teams.
  51. ---
  52. ## Table of Contents
  53. - [🏆 Benchmarks](#-benchmarks)
  54. - [🚀 Quick Start](#-quick-start)
  55. - [🧠 How Memory Works](#-how-memory-works)
  56. - [Consolidation](#consolidation--n--1)
  57. - [Decay](#decay--the-forgetting-curve)
  58. - [Hybrid Retrieval](#hybrid-retrieval--vector--bm25--graph)
  59. - [🔒 Trust & Audit Trail](#-trust--audit-trail)
  60. - [👥 Team Memory Pools](#-team-memory-pools)
  61. - [🛡️ Data Rights & Compliance](#️-data-rights--compliance)
  62. - [🎛️ Dashboards](#️-dashboards)
  63. - [🔧 MCP Tools](#-mcp-tools)
  64. - [⚡ Ask Without an LLM Call](#-ask-without-an-llm-call)
  65. - [🔀 API Proxy — Guaranteed Memory](#-api-proxy--guaranteed-memory)
  66. - [🏗️ Architecture & Stack](#️-architecture--stack)
  67. - [🩺 Troubleshooting](#-troubleshooting)
  68. - [🤝 Contributing](#-contributing)
  69. ---
  70. ## 🏆 Benchmarks
  71. Three external datasets. Every number independently reproducible — [benchmark code lives in the repo](benchmarks/). Full methodology in [BENCHMARKS.md](BENCHMARKS.md).
  72. ### LoCoMo-10 — multi-session conversational memory
  73. ```mermaid
  74. xychart-beta
  75. title "Recall@5 · LoCoMo-10 (higher is better)"
  76. x-axis ["Mem0", "Zep Cloud", "Supermemory", "YourMemory"]
  77. y-axis "Recall@5 percent" 0 --> 70
  78. bar [18, 28, 31, 59]
  79. ```
  80. > **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.
  81. ### LongMemEval-S — 500 questions, ~53 distractor sessions each
  82. The hardest standard benchmark for long-term memory. Each question is buried in ~53 sessions.
  83. | Metric | Score |
  84. |--------|:-----:|
  85. | **Recall@5** (any gold session in top-5) | **89.4%** |
  86. | Recall-all@5 (all gold sessions in top-5) | 84.8% |
  87. | nDCG@5 (ranking quality) | 87.4% |
  88. ### HotpotQA — 200 multi-hop questions
  89. | System | BOTH_FOUND@5 |
  90. |--------|:------------:|
  91. | **YourMemory** (vector + BM25 + entity graph) | **71.5%** |
  92. | YourMemory (no entity edges) | 59.5% |
  93. 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.
  94. *Writeup: [I built memory decay for AI agents using the Ebbinghaus forgetting curve](https://dev.to/sachit_mishra_686a94d1bb5/i-built-memory-decay-for-ai-agents-using-the-ebbinghaus-forgetting-curve-1b0e)*
  95. ---
  96. ## 🚀 Quick Start
  97. **Python 3.11–3.14. No Docker, no database setup. All memory stored locally in `~/.yourmemory/`.**
  98. ```bash
  99. pip install yourmemory
  100. yourmemory-register <your-token>
  101. yourmemory-setup
  102. ```
  103. **Get your token:** visit **[yourmemoryai.xyz](https://yourmemoryai.xyz/)** → enter your email → verify with a 6-digit code → copy your token.
  104. `yourmemory-setup` auto-detects and wires up **Claude Code, Claude Desktop, Cursor, Windsurf, and Cline**, then asks which backend to use:
  105. - **DuckDB** — zero setup, single local file *(default)*
  106. - **Postgres** — shared / production; you provide a `DATABASE_URL` (needs the pgvector extension)
  107. > **Optional — smarter local extraction:** YourMemory works out of the box with built-in heuristics. For higher-quality, fully-local fact extraction, install [Ollama](https://ollama.com) and `yourmemory-setup` pulls the model (`qwen2.5:7b`, ~4.7 GB) automatically. Prefer the cloud? Set `YOURMEMORY_EXTRACT_BACKEND=anthropic`.
  108. ### Or install from a binary — no Python required
  109. Prefer not to touch pip? Grab the standalone binary for your platform from the [latest release](https://github.com/sachitrafa/YourMemory/releases/latest):
  110. | Platform | Asset |
  111. |----------|-------|
  112. | macOS (Apple Silicon) | `yourmemory-macos-arm64.tar.gz` |
  113. | macOS (Intel) | `yourmemory-macos-x86_64.tar.gz` |
  114. | Linux (x86-64) | `yourmemory-linux-x86_64.tar.gz` |
  115. | Windows (x86-64) | `yourmemory-windows-x86_64.exe.zip` |
  116. ```bash
  117. # macOS / Linux — download, extract, run
  118. tar -xzf yourmemory-macos-arm64.tar.gz
  119. ./yourmemory-macos-arm64 register <your-token>
  120. ./yourmemory-macos-arm64 setup
  121. ./yourmemory-macos-arm64 # start the server
  122. ```
  123. One executable handles every command: `register`, `setup`, `ask "<question>"`, `path`, and (with no args) starts the server.
  124. **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](.github/workflows/build-binary.yml).
  125. ---
  126. ## 🧠 How Memory Works
  127. YourMemory treats memory as a living system — it **grows, consolidates, forgets, and connects**, the way a brain does.
  128. ### Consolidation — *N → 1*
  129. 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).
  130. ```mermaid
  131. flowchart LR
  132. subgraph before [Related facts pile up]
  133. A1["Railway uses Nixpacks"]
  134. A2["Railway on Pro plan"]
  135. A3["Railway env vars hold<br/>the Postgres URL"]
  136. A4["Deploys on Railway<br/>with Postgres"]
  137. end
  138. before --> C{"cluster +<br/>LLM summarize"}
  139. C --> S["✨ Summary<br/>Deploys on Railway (Pro,<br/>Nixpacks) with Postgres<br/>via env vars"]
  140. C -.->|"archived, recoverable"| ARC[("archive")]
  141. style S fill:#0a2540,stroke:#5eead4,color:#fff
  142. style C fill:#0c2b3a,stroke:#19cdff,color:#fff
  143. ```
  144. > 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.
  145. ### Decay — the forgetting curve
  146. Memory strength decays exponentially. Importance and recall frequency slow that decay:
  147. ```
  148. effective_λ = base_λ × (1 − importance × 0.8)
  149. strength = clamp(importance × e^(−effective_λ × active_days) × (1 + recall_count × 0.2), 0, 1)
  150. ```
  151. `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:
  152. | Category | Half-life | Best for |
  153. |----------|:---------:|----------|
  154. | `strategy` | ~38 days | Patterns that worked, architectural decisions |
  155. | `fact` | ~24 days | Preferences, identity, stable knowledge |
  156. | `assumption` | ~19 days | Inferred context, uncertain beliefs |
  157. | `failure` | ~11 days | Errors, wrong approaches, environment-specific issues |
  158. **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.
  159. ### Hybrid Retrieval — Vector + BM25 + Graph
  160. Recall runs in two rounds so it surfaces both what you asked for *and* what you forgot to ask for:
  161. ```mermaid
  162. flowchart LR
  163. Q["query"] --> R1["Vector + BM25<br/>hybrid search"]
  164. R1 --> R2["Graph expansion<br/>(what you forgot to ask)"]
  165. R2 --> S["rank by<br/>similarity × strength"]
  166. S --> OUT["🎯 Ranked memories"]
  167. style OUT fill:#0a2540,stroke:#19cdff,color:#fff
  168. ```
  169. **Subject-aware deduplication** runs before every store — it embeds the subject of each sentence so `"Sachit uses DuckDB"` and `"YourMemory uses DuckDB"` stay separate (different entities), while `"YourMemory uses DuckDB"` and `"YourMemory stores data in DuckDB"` merge (same entity). No hardcoded word lists; generalises to any language.
  170. ---
  171. ## 🔒 Trust & Audit Trail
  172. Enterprises won'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**.
  173. ```mermaid
  174. flowchart LR
  175. E0["GENESIS"] --> E1
  176. subgraph E1 [Event 1]
  177. H1["row_hash =<br/>sha256(prev + data)"]
  178. end
  179. E1 --> E2
  180. subgraph E2 [Event 2]
  181. H2["row_hash =<br/>sha256(#1.hash + data)"]
  182. end
  183. E2 --> E3
  184. subgraph E3 [Event 3]
  185. H3["row_hash =<br/>sha256(#2.hash + data)"]
  186. end
  187. E3 --> V{"GET /audit/verify"}
  188. V -->|chain intact| OK["✅ verified"]
  189. V -->|any row altered| BAD["❌ chain breaks<br/>at that row"]
  190. style OK fill:#0a2540,stroke:#5eead4,color:#fff
  191. style BAD fill:#3a0c14,stroke:#fb7185,color:#fff
  192. ```
  193. 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.
  194. ```bash
  195. GET /audit # browse the trail (filter by user / action / operation)
  196. GET /audit/verify # cryptographically verify the chain is untampered
  197. POST /audit/prune # retention-based cleanup (90-day minimum, never lower)
  198. ```
  199. > Audit logging is **fail-open** — it never blocks a memory operation — and read/list events from the dashboard's own render loop are excluded, so the trail stays signal, not noise.
  200. ---
  201. ## 👥 Team Memory Pools
  202. Give a whole team's agents one shared brain — without leaking anyone's private context. Memories are either **shared** (visible to the pool) or **private** (visible only to their owner).
  203. ```mermaid
  204. flowchart TB
  205. P(("🧠 Team Pool<br/>shared memory"))
  206. A["Alice's agent"] <-->|shared| P
  207. B["Bob's agent"] <-->|shared| P
  208. C["Carol's agent"] <-->|shared| P
  209. A -. private .-> AP["🔒 Alice-only"]
  210. B -. private .-> BP["🔒 Bob-only"]
  211. style P fill:#0a2540,stroke:#19cdff,color:#fff
  212. style AP fill:#0c1424,stroke:#5a6b80,color:#8294a8
  213. style BP fill:#0c1424,stroke:#5a6b80,color:#8294a8
  214. ```
  215. 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.
  216. ```bash
  217. POST /pools # create a pool
  218. POST /pools/{id}/members # add a member (with role)
  219. POST /pools/{id}/memories # contribute a shared memory
  220. POST /pools/{id}/retrieve # recall across the pool
  221. ```
  222. ---
  223. ## 🛡️ Data Rights & Compliance
  224. Because memory that stores real data needs the controls to be trusted with it:
  225. | Right | Endpoint | What it does |
  226. |-------|----------|--------------|
  227. | **Access** (DSAR export) | `GET /users/{id}/export` | Full export of everything stored for a user |
  228. | **Erasure** (right to forget) | `DELETE /users/{id}/memories` | One-command purge of a user's memories |
  229. | **Portability** | `POST /users/{id}/import` | Re-import a previous export |
  230. | **Recoverability** | `GET /users/{id}/archive` | Retrieve consolidated-away originals |
  231. Combined with the hash-chained audit trail and 90-day retention floor, these map directly onto the controls documented in [SECURITY.md](SECURITY.md) (SOC 2-aligned).
  232. ---
  233. ## 🎛️ Dashboards
  234. Two built-in browser UIs — no extra setup, they start automatically with the server.
  235. ### Memory Dashboard — `http://localhost:3033/ui`
  236. 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.
  237. ### Graph Visualiser — `http://localhost:3033/graph`
  238. 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.
  239. ```
  240. http://localhost:3033/graph?memoryId=42&userId=alex&depth=2
  241. ```
  242. ---
  243. ## 🔧 MCP Tools
  244. Three tools, called by your AI automatically.
  245. | Tool | When your AI calls it | What it does |
  246. |------|-----------------------|--------------|
  247. | `recall_memory(query, current_path?)` | Start of every task | Surfaces memories ranked by similarity × decay strength; spatial boost for path-matched memories |
  248. | `store_memory(content, importance, category?, context_paths?)` | After learning something new | Embeds, deduplicates, stores with decay; tags optional file/dir paths |
  249. | `update_memory(id, new_content, importance)` | When a stored fact is outdated | Re-embeds and replaces; logs the change to the audit trail |
  250. ```python
  251. # Store with spatial context
  252. store_memory(
  253. "Alex prefers tabs over spaces in Python",
  254. importance=0.9, category="fact",
  255. context_paths=["/projects/backend"],
  256. )
  257. # Next session — spatial boost fires when working in that directory
  258. recall_memory("Python formatting", current_path="/projects/backend")
  259. # → {"content": "Alex prefers tabs over spaces in Python", "strength": 0.87}
  260. ```
  261. ---
  262. ## ⚡ Ask Without an LLM Call
  263. The only memory system that can answer questions **without making any LLM API call**:
  264. ```bash
  265. yourmemory ask "what database does this project use"
  266. # → YourMemory uses DuckDB locally and Postgres in production.
  267. yourmemory ask "how do I fix a kubernetes deployment"
  268. # → Not enough memory context to answer without an LLM.
  269. ```
  270. When memory is strong enough it answers instantly — zero tokens, zero cloud cost, zero latency. When it isn't, it declines cleanly rather than hallucinating. Your query never leaves your machine.
  271. ---
  272. ## 🔀 API Proxy — Guaranteed Memory
  273. MCP tools are called at the AI'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.
  274. Start the server (`yourmemory`), then point your client at `localhost:3033`:
  275. ```python
  276. from anthropic import Anthropic
  277. client = Anthropic(
  278. api_key="sk-ant-...",
  279. base_url="http://localhost:3033/proxy/anthropic",
  280. default_headers={"X-YourMemory-User": "alex"}, # per-user memory
  281. )
  282. # Memory is injected automatically — no other changes needed
  283. response = client.messages.create(
  284. model="claude-opus-4-8",
  285. max_tokens=1024,
  286. messages=[{"role": "user", "content": "What database do I use?"}],
  287. )
  288. ```
  289. OpenAI works identically via `base_url="http://localhost:3033/proxy/openai"`.
  290. ---
  291. ## 🏗️ Architecture & Stack
  292. ```mermaid
  293. flowchart LR
  294. C["Your AI client<br/>Claude · Cursor · any MCP"] <--> Y["🧠 YourMemory"]
  295. Y --> M[("Memory<br/>store")]
  296. Y --> A[("Audit<br/>ledger")]
  297. style Y fill:#0a2540,stroke:#19cdff,color:#fff
  298. style M fill:#0c1a2c,stroke:#5eead4,color:#fff
  299. style A fill:#0c1a2c,stroke:#5eead4,color:#fff
  300. ```
  301. | Component | Role |
  302. |-----------|------|
  303. | **DuckDB** | Default vector store — zero setup, native cosine similarity |
  304. | **PostgreSQL + pgvector** | Optional — for teams or large datasets |
  305. | **NetworkX** | Default graph backend (`~/.yourmemory/graph.pkl`) |
  306. | **Neo4j** | Optional graph backend |
  307. | **sentence-transformers** | Local embeddings (`multi-qa-mpnet-base-dot-v1`, 768 dims) |
  308. | **spaCy** | Local NLP for deduplication and entity extraction |
  309. | **APScheduler** | Automatic decay + pruning |
  310. ---
  311. ## 🩺 Troubleshooting
  312. **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:
  313. ```bash
  314. pkill -f yourmemory 2>/dev/null || true
  315. rm -f ~/.yourmemory/memories.duckdb.wal ~/.yourmemory/memories.duckdb.lock 2>/dev/null || true
  316. # restart your client
  317. ```
  318. Running Claude Desktop (MCP) and Claude Code (hooks) simultaneously? Use SQLite instead — it handles concurrent readers/writers cleanly:
  319. `DATABASE_URL=sqlite:///~/.yourmemory/memories.db`
  320. ---
  321. ## 🤝 Contributing
  322. PRs welcome — see [CONTRIBUTORS.md](CONTRIBUTORS.md).
  323. ## 📚 Dataset References
  324. - [LoCoMo](https://github.com/snap-research/locomo) — Maharana et al. (2024)
  325. - [LongMemEval](https://github.com/xiaowu0162/LongMemEval) — Wu et al. (2024)
  326. - [HotpotQA](https://hotpotqa.github.io/) — Yang et al. (2018)
  327. ## 📄 License
  328. Copyright 2026 **Sachit Misra** — Licensed under [CC-BY-NC-4.0](LICENSE).
  329. **Free for** personal use, education, academic research, and open-source projects.
  330. **Commercial use** requires a separate written agreement → mishrasachit1@gmail.com
  331. <div align="center"><br><b>Give your AI a memory worth keeping.</b><br><code>pip install yourmemory</code></div>

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.