Skip to content
Back to search

iai-pme

The personal memory engine for AI coding assistants — local, encrypted, verbatim.

Safety scan

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

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/CodeAbra/iai-personal-memory-engine with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/CodeAbra/iai-personal-memory-engine'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/codeabra--iai-personal-memory-engine/badge.svg)](/listings/codeabra--iai-personal-memory-engine)

HTML

<a href="/listings/codeabra--iai-personal-memory-engine"><img src="/api/listings/codeabra--iai-personal-memory-engine/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.

These steps run a script from the network that findsafeskills does not scan.

Claude Code

python3.12 -m pip install -U iai-pme

Then run inside Claude Code:

/plugin marketplace add CodeAbra/iai-personal-memory-engine
/plugin install iai-memory@iai-pme

Restart the session, then verify:

iai --version
iai-mcp daemon status
iai-mcp doctor

Python 3.11 is also supported.

macOS or Linux: all-in-one source install

curl -fsSL https://raw.githubusercontent.com/CodeAbra/iai-personal-memory-engine/main/scripts/bootstrap.sh | bash

This builds the Rust engine and TypeScript wrapper, installs the background service and hooks, registers Claude Code, and runs the health check. It requires Git, Python 3.11/3.12, Node.js 18+, and Rust. To inspect the steps without changing anything:

curl -fsSL https://raw.githubusercontent.com/CodeAbra/iai-personal-memory-engine/main/scripts/bootstrap.sh | bash -s -- --dry-run

Other hosts

python3.12 -m pip install -U iai-pme
iai-mcp crypto init
iai-mcp daemon install
iai-mcp capture-hooks install --target codex

Replace `codex` with `cursor`, `antigravity`, `hermes`, `openclaw`, or `all`. MCP tools work with any MCP-over-stdio client; automatic capture and context injection depend on the hooks exposed by the host. See the [technical reference](docs/REFERENCE.md).

New stores use the native engine format by default; an existing store keeps its current format on upgrade. To move an existing legacy SQLite store onto the native engine, run `iai-mcp migrate-to-lilli` — `iai-mcp doctor` prints the exact command, and the [technical reference](docs/REFERENCE.md) documents the full flow.

---

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.

.claude-plugin/marketplace.json · Manifest · 17 lines

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

  1. {
  2. "name": "iai-pme",
  3. "owner": {
  4. "name": "Areg Aramovich Noya",
  5. "url": "https://github.com/CodeAbra"
  6. },
  7. "description": "The personal memory engine for AI coding assistants — local, encrypted, verbatim.",
  8. "plugins": [
  9. {
  10. "name": "iai-memory",
  11. "source": "./plugin",
  12. "description": "Persistent local memory for your assistant: every turn captured verbatim, relevant memory injected at session start and before each turn, and fifteen memory tools over MCP. Requires the iai-pme package (pip install iai-pme).",
  13. "category": "productivity",
  14. "tags": ["memory", "recall", "local-first", "mcp", "context"]
  15. }
  16. ]
  17. }
README.md · README · 336 lines · 2 findings marked

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

  1. **English** | [中文](./README_zh-CN.md)
  2. <p align="center">
  3. <img src="docs/assets/iai-memory-banner.png" alt="iai-memory — a personal memory engine for your AI coding workflow" width="100%">
  4. </p>
  5. <p align="center">
  6. <b>Keeps every conversation word-for-word and gives your AI agent the right<br>
  7. context on every turn.</b>
  8. </p>
  9. <p align="center">
  10. <img src="docs/assets/iai-brain-demo.gif" alt="iai-memory searching, recalling, pinning, fading, rescuing, and learning a file" width="850">
  11. </p>
  12. <p align="center">
  13. <a href="https://pypi.org/project/iai-pme/"><img src="https://img.shields.io/pypi/v/iai-pme?style=flat-square&color=1f6feb&label=pypi" alt="iai-memory on PyPI"></a>
  14. <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-1f6feb?style=flat-square" alt="MIT License"></a>
  15. <img src="https://img.shields.io/badge/python-3.11%20%7C%203.12-3776ab?style=flat-square&logo=python&logoColor=white" alt="Python 3.11 or 3.12">
  16. <img src="https://img.shields.io/badge/macOS%20%7C%20Linux-supported-555?style=flat-square" alt="macOS and Linux supported">
  17. <img src="https://img.shields.io/badge/Windows-beta-dbab09?style=flat-square&logo=windows&logoColor=white" alt="Windows beta">
  18. <img src="https://img.shields.io/badge/MCP-compatible-8957e5?style=flat-square" alt="MCP compatible">
  19. </p>
  20. <p align="center">
  21. <img src="https://img.shields.io/badge/Rescue%4010-1.000-2ea043?style=flat-square" alt="Rescue@10 1.000">
  22. <img src="https://img.shields.io/badge/LongMemEval%20R%405-0.962-2ea043?style=flat-square" alt="LongMemEval R@5 0.962">
  23. <img src="https://img.shields.io/badge/historical--verbatim-1.000-2ea043?style=flat-square" alt="Historical-verbatim hit@10 1.000">
  24. <img src="https://img.shields.io/badge/at%20rest-AES--256--GCM-2ea043?style=flat-square" alt="AES-256-GCM at rest">
  25. </p>
  26. <p align="center">
  27. <a href="#quick-start"><b>Quick start</b></a> ·
  28. <a href="#how-it-works"><b>How it works</b></a> ·
  29. <a href="#benchmarks"><b>Benchmarks</b></a> ·
  30. <a href="#compatibility"><b>Compatibility</b></a> ·
  31. <a href="docs/REFERENCE.md"><b>Technical reference</b></a>
  32. </p>
  33. ---
  34. ## What it is
  35. A local server that speaks the MCP protocol and gives Claude, and any other
  36. MCP-compatible agent, a long-term memory. It captures every turn of every session
  37. verbatim, organizes those captures over time into a personal map of who you are,
  38. and serves a small slice of relevant memory back at the start of each new
  39. conversation and turn. You never have to say *"remember this"* or *"what did we
  40. say last time?"*.
  41. I built this for myself. It worked. The benchmarks were mostly for my own
  42. curiosity.
  43. Under the hood it's not a wrapper around someone else's vector store and graph
  44. library — the parts that matter are my own code: the storage engine, the
  45. community-detection algorithm, the hyperdimensional memory substrate, and a
  46. native engine that makes it fast.
  47. And unlike cloud memory services, there's no API key, no account, and no
  48. telemetry: the engine, the store, and the embeddings all run locally. The only
  49. things that leave your machine are the normal model calls your CLI already makes,
  50. a nightly consolidation step that asks your model for a single insight through
  51. the same subscription your CLI already uses (on by default;
  52. `IAI_MCP_REM_DISABLED=1` turns it off), a daily version check, and the one-time
  53. download of the embedding model.
  54. ---
  55. ## Quick start
  56. ### Claude Code
  57. ```bash
  58. python3.12 -m pip install -U iai-pme
  59. ```
  60. Then run inside Claude Code:
  61. ```text
  62. /plugin marketplace add CodeAbra/iai-personal-memory-engine
  63. /plugin install iai-memory@iai-pme
  64. ```
  65. Restart the session, then verify:
  66. ```bash
  67. iai --version
  68. iai-mcp daemon status
  69. iai-mcp doctor
  70. ```
  71. Python 3.11 is also supported.
  72. ### macOS or Linux: all-in-one source install
  73. ```bash
  74. curl -fsSL https://raw.githubusercontent.com/CodeAbra/iai-personal-memory-engine/main/scripts/bootstrap.sh | bash
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 97 on GitHub
  75. ```
  76. This builds the Rust engine and TypeScript wrapper, installs the background
  77. service and hooks, registers Claude Code, and runs the health check. It requires
  78. Git, Python 3.11/3.12, Node.js 18+, and Rust. To inspect the steps without
  79. changing anything:
  80. ```bash
  81. curl -fsSL https://raw.githubusercontent.com/CodeAbra/iai-personal-memory-engine/main/scripts/bootstrap.sh | bash -s -- --dry-run
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 106 on GitHub
  82. ```
  83. ### Other hosts
  84. ```bash
  85. python3.12 -m pip install -U iai-pme
  86. iai-mcp crypto init
  87. iai-mcp daemon install
  88. iai-mcp capture-hooks install --target codex
  89. ```
  90. Replace `codex` with `cursor`, `antigravity`, `hermes`, `openclaw`, or `all`.
  91. MCP tools work with any MCP-over-stdio client; automatic capture and context
  92. injection depend on the hooks exposed by the host. See the
  93. [technical reference](docs/REFERENCE.md).
  94. New stores use the native engine format by default; an existing store keeps its
  95. current format on upgrade. To move an existing legacy SQLite store onto the
  96. native engine, run `iai-mcp migrate-to-lilli` — `iai-mcp doctor` prints the exact
  97. command, and the [technical reference](docs/REFERENCE.md) documents the full flow.
  98. ---
  99. ## What happens after installation
  100. | Event | Action |
  101. |---|---|
  102. | Prompt | New turns are appended to a session buffer as file IO; no embedding or engine RPC is needed on the capture path |
  103. | Session end | Remaining transcript content is rolled over for ingestion; hook failures do not block the host |
  104. | Session start | A bounded memory prefix is exposed as host context; an empty store or unavailable engine yields empty output |
  105. | Later turns | Supported hosts receive a small foresight or delta pack with age and revision markers |
  106. | Idle time | Captures are embedded, deduplicated, encrypted, inserted, clustered, consolidated, reinforced, and decayed |
  107. The background process is called the `daemon` in the CLI. The MCP wrapper and
  108. `iai` can still read the local store directly when it is asleep or temporarily
  109. unavailable.
  110. ---
  111. ## How it works
  112. ### Memory model
  113. | Tier | Contains |
  114. |---|---|
  115. | **Episodic** | Timestamped, write-once fragments of what was said |
  116. | **Semantic** | Summaries induced from related episodes during idle consolidation |
  117. | **Procedural** | Ten bounded behavioural parameters learned over time |
  118. Distinct hyperdimensional representations keep literal detail, semantic
  119. structure, and behavioural tendencies from collapsing into one vector surface.
  120. The local, LLM-free recall path combines semantic similarity, graph evidence,
  121. recency, temporal validity, and lexical evidence. `memory_recall` returns both
  122. `hits` and `anti_hits`; `memory_contradict` closes the old record's validity
  123. interval, creates a new record, and links the two.
  124. While idle, the engine groups related episodes, induces semantic memory,
  125. reinforces useful paths, and decays weak unreviewed edges. One REM step, on by
  126. default, may invoke `claude -p` through the user's existing Claude subscription,
  127. capped at no more than 1% of the daily quota; `IAI_MCP_REM_DISABLED=1` turns it
  128. off. No Anthropic API key is required.
  129. ### First-party components
  130. | Component | Role |
  131. |---|---|
  132. | **Hippo** | Encrypted records, vector index, and graph in one local store |
  133. | **MOSAIC** | Leiden-family community detection with stable community identity |
  134. | **Lilli HD** | Hyperdimensional substrate and structural recall |
  135. | **Native engine** | Rust embedder and graph kernels |
  136. ---
  137. ## Dashboard and CLI
  138. ```bash
  139. iai brain
  140. ```
  141. The local dashboard searches the store, exposes graph neighbourhoods and
  142. contradictions, pins or fades memories, ingests files, controls the background
  143. engine, and reports token-use estimates from your own store.
  144. ```text
  145. iai recall · temporal-recall · search · ask · capture · teach · upload
  146. iai watch · brain · status · last
  147. ```
  148. `iai upload` accepts documents, Office files, e-books, source code,
  149. configuration files, and directories. Full formats and administrative commands
  150. are listed in [`docs/REFERENCE.md`](docs/REFERENCE.md).
  151. ---
  152. ## Benchmarks
  153. Every harness ships in `bench/`; methodology and reproduce commands are in
  154. [`BENCHMARKS.md`](BENCHMARKS.md).
  155. | Benchmark | Result |
  156. |---|---:|
  157. | Rescue@10 after contradiction | **1.000** |
  158. | Historical-verbatim hit@10 | **1.000** |
  159. | LongMemEval-S R@5, product embedder | **0.962** |
  160. | LongMemEval-S R@10, product embedder | **0.978** |
  161. Historical-verbatim retrieval uses a flat-cosine baseline of about 0.71. With
  162. the matched `all-MiniLM-L6-v2` embedder, iai-memory and mempalace v3.3.6 both
  163. score R@5 `0.966` and R@10 `0.978`; no win is claimed.
  164. On the author's store, an automatically injected memory pack averaged about
  165. 350 tokens versus about 2,850 tokens for the agent-search round trip it
  166. replaced: approximately 88% cheaper on that measured workload. This does not
  167. apply to explicit `memory_recall`, whose default response budget is 1,500
  168. tokens.
  169. ---
  170. ## MCP tools
  171. ```text
  172. memory_recall memory_temporal_recall
  173. memory_recall_structural memory_search
  174. memory_capture memory_contradict
  175. memory_reinforce memory_consolidate
  176. profile_get_set topology
  177. schema_list events_query
  178. episodes_recent curiosity_pending
  179. claim_check
  180. ```
  181. Fifteen tools cover cue, temporal, structural, and lexical recall; checking a
  182. claim against memory; capture and correction; reinforcement and consolidation;
  183. behavioural-profile control; and store introspection.
  184. ---
  185. ## Compatibility
  186. | Host | Ambient behaviour |
  187. |---|---|
  188. | **Claude Code** | Session-start recall, per-turn updates, turn capture, and session capture |
  189. | **Codex CLI** | Full integration through Codex hooks |
  190. | **Cursor** | Session-start recall and capture; no per-turn text injection |
  191. | **Antigravity** | Recall per invocation and lossless transcript capture |
  192. | **Hermes 0.5.0+** | Recall before model calls and capture from its message store |
  193. | **OpenClaw** | MCP tools on request; no ambient shell hooks |
  194. | **Gemini CLI and other MCP hosts** | MCP tools; no bundled host-specific hooks unless listed above |
  195. | **Claude Desktop** | MCP tools; plain Chat does not expose Claude Code-style ambient hooks |
  196. ---
  197. ## Privacy and limitations
  198. - Records are encrypted at rest with AES-256-GCM. The store and key live under
  199. `~/.iai-mcp/`; back them up together. Two kinds of files there are plain
  200. text: the per-turn capture spool until the engine's next pass encrypts it,
  201. and the caches the hooks inject memory from. The
  202. [plugin README](plugin/README.md#privacy) lists them.
  203. - macOS and Linux use a Unix socket. Windows uses an ephemeral loopback port
  204. with a per-user token.
  205. - There is no iai-memory account, telemetry pipeline, hosted dashboard, or
  206. cross-machine sync.
  207. - iai-memory goes online in three places, each with an off switch: the nightly
  208. REM `claude -p` step (on by default, `IAI_MCP_REM_DISABLED=1`), a daily PyPI
  209. version check (`IAI_MCP_VERSION_CHECK=0`), and the first-use download of the
  210. embedding model from Hugging Face (`IAI_MCP_EMBED_OFFLINE=1`).
  211. - The engine checks that your Claude Code login is a subscription by reading
  212. Claude Code's login record (`~/.claude/.credentials.json`, or the macOS
  213. Keychain item) when the MCP server starts and before the REM step. Nothing
  214. from the record is sent anywhere.
  215. - The MCP server starts the engine in the background, and it keeps running
  216. after the session ends. Stop it with `iai-mcp daemon stop`.
  217. - The store refuses to mix incompatible embedding generations; changing the
  218. embedder requires an explicit migration.
  219. - Recall is usually mediocre during roughly the first ten sessions, and quality
  220. and latency depend on corpus size, language, embedder, and stored history.
  221. - The default store is English-first. Raw non-English records require an
  222. explicit `raw:<lang>` tag and a multilingual or custom embedder.
  223. - Windows support is beta. Ambient behaviour varies with host hook support.
  224. - The project is solo-maintained and has no enterprise SLA.
  225. Health and updates:
  226. ```bash
  227. iai-mcp doctor # 38 checks
  228. iai-mcp daemon status
  229. iai-mcp self-update
  230. ```
  231. ---
  232. ## About the name
  233. **IAI — Independent Autistic Intelligence** describes the memory design.
  234. - **Independent:** the engine, store, embeddings, and dashboard run locally.
  235. - **Autistic:** literal preservation, precise cues, sustained focus, and rare
  236. events retained as rare rather than smoothed into a typical summary. This is
  237. an operational design description, not a diagnosis or casual metaphor.
  238. - **Intelligence:** used in the systems sense — a process that observes,
  239. adapts, reorganizes itself, and remains viable over time.
  240. “Personal memory engine” describes the scope: one person's memory, on one
  241. machine, used by the assistant they already have.
  242. ---
  243. ## Documentation
  244. - [`docs/REFERENCE.md`](docs/REFERENCE.md) — technical and operational reference
  245. - [`BENCHMARKS.md`](BENCHMARKS.md) — methodology and reproduce commands
  246. - [`docs/EMBEDDERS.md`](docs/EMBEDDERS.md) — providers, languages, and migrations
  247. - [`CHANGELOG.md`](CHANGELOG.md) — release history
  248. - [`CONTRIBUTING.md`](CONTRIBUTING.md) — development and test setup
  249. - [`SECURITY.md`](SECURITY.md) — private vulnerability reporting
  250. Issues and pull requests are welcome. Changes to retrieval, capture,
  251. contradiction handling, or consolidation should include relevant benchmark
  252. reruns.
  253. ## Authors
  254. By Areg Aramovich Noya and Lilli Noya, in collaboration with the team at
  255. [lcgc.dev](https://lcgc.dev).
  256. ## License
  257. [MIT](LICENSE)

Ratings and comments

Sign in to rate this skill.

Sign in

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