PME — The only AI memory tool with cross-project intelligence

PME gives Claude Code persistent memory that learns across all your projects. Decisions, constraints, promises, and checkpoints survive across sessions. Patterns discovered in one project surface automatically in another. It works invisibly — hooks handle everything, zero explicit tool calls needed for daily use.

What sets PME apart: while every other memory tool stores what you tell it within a single project, PME detects patterns across your entire project portfolio and pushes them to you before you repeat mistakes.

Quick Start

# Add the PME marketplace source (one-time)
claude plugin marketplace add pme-marketplace https://github.com/ideep40/pme-plugin.git

# Install the plugin
claude plugin install pme@pme-marketplace

Open any repo. PME auto-detects the project (or bootstraps a new one), injects context into Claude's first response, and starts capturing decisions automatically. No configuration. No manual setup.

Update to latest:

claude plugin marketplace update pme-marketplace
claude plugin update pme@pme-marketplace

First session output:

<pme-context project="my-api">
Summary: REST API for user management. Tech: express, prisma, typescript

Key knowledge:
- [decision] Use PostgreSQL for persistence
- [constraint] All endpoints must validate JWT tokens
- [learning] Connection pooling improves p99 by 40%

Open promises:
- Add rate limiting [trigger: after v2.0 release]

Cross-project insights:
- Rate limiting was retrofitted late in 2 similar Express projects at high cost — consider adding early

Last session: Implemented user search endpoint
Open threads: Pagination strategy still open
</pme-context>

What Makes PME Different

Cross-project intelligence

PME tracks patterns across all your projects. When you make an architectural decision, PME checks whether you or your other projects have learned something relevant — and surfaces it automatically. No other memory tool does this.

• Patterns detected across projects accumulate higher trust the more projects confirm them
• "Lessons from other projects" surface when you return to a dormant repo after 7+ days
• Auto-advise triggers when a decision is captured — relevant cross-project warnings appear in the next session primer

Developer workflow primitives

PME is purpose-built for software development, not general AI memory:

• Promises — deferred work with revisit triggers ("add rate limiting after v2.0")
• Checkpoints — stable milestones that anchor the project history
• Drift detection — flags when new decisions contradict existing ones
• Diff analysis — surfaces knowledge gaps when code changes diverge from decisions

Invisible infrastructure

Hooks handle everything. For most sessions, zero explicit PME tool calls are needed:

• SessionStart: project context injected before Claude's first response
• UserPromptSubmit: decisions, learnings, and constraints captured as you work
• Stop: session digest auto-generated and stored after every session

Memory quality

PME actively maintains the knowledge base rather than accumulating noise:

• Trust scoring — knowledge ranked by source, recency, validation, and cross-project confirmation
• Confidence decay — stale items fade; frequently-confirmed items strengthen
• Contradiction resolution — conflicting knowledge flagged and auto-resolved
• Hygiene — near-duplicates merged, tags normalized, stale items decayed automatically
• PII/secret filtering — API keys, tokens, passwords auto-redacted before storage

PME vs Alternatives

| Capability | PME | claude-mem | Mem0 | Built-in CLAUDE.md / MEMORY.md | Cursor/Windsurf | |---|:---:|:---:|:---:|:---:|:---:| | Cross-project intelligence | Yes | No | No | No | No | | Auto-capture (ambient) | Yes | Yes | No | Yes (MEMORY.md) | Partial | | Session context injection | Yes | Yes | No | Yes | Yes | | Developer workflow primitives (promises, checkpoints, drift) | Yes | No | No | No | No | | Confidence decay + hygiene | Yes | No | No | No | No | | Contradiction detection | Yes | No | No | No | No | | Git-native memory branching | Yes | No | No | No | No | | Explainable recall | Yes | No | No | No | No | | PII/secret filtering | Yes | No | No | No | No | | Self-editing memory | Yes | No | No | No | No | | Value attribution | Yes | No | No | No | No | | Fully local / private | Yes | Yes | No (cloud) | Yes | No (cloud) | | Vector/semantic embeddings | FTS5 hybrid | Yes | Yes | No | No |

vs claude-mem: claude-mem is excellent for auto-capture and has 21K+ stars. It has no cross-project intelligence, no workflow primitives (promises, checkpoints), and no memory quality pipeline. PME is the choice if you want patterns to surface across projects and deferred work tracked.

vs Mem0: Mem0 is a general AI memory platform (graph + vector, $24M Series A). Not developer-specific, requires cloud, no workflow primitives. PME stays local and is purpose-built for Claude Code.

vs built-in CLAUDE.md / MEMORY.md: Claude's native memory (free as of March 2026) handles general persistence. PME adds cross-project intelligence, structured knowledge types, workflow primitives, and a quality pipeline that maintains the knowledge base over time.

vs Cursor/Windsurf: IDE-scoped, cloud-backed, no cross-project awareness, no workflow primitives. PME is Claude Code-native and fully local.

How It Works

PME runs three components, all local:

• MCP server (npx pme-server) — tool surface for explicit knowledge operations (44+ tools)
• Worker service — persistent HTTP process handling real-time capture, auto-advise, and session digests
• Plugin shell hooks — ultra-thin clients for SessionStart, UserPromptSubmit, Stop

Storage: SQLite at ~/.pme/projects.db (WAL mode). All data is on your machine. Nothing leaves your device.

Privacy

Fully local. ~/.pme/projects.db on your machine. No external services. Worker runs on 127.0.0.1 with a dynamic port. Inspect, export, or delete data at any time via pme_export or by accessing the SQLite file directly.

For Power Users

Most sessions need zero explicit tool calls. When you do need them:

• pme_store_knowledge — explicit capture ("remember this")
• pme_mark_checkpoint — record a stable milestone
• pme_advise — query cross-project intelligence on demand
• pme_store_promise — track deferred work with a revisit trigger
• pme_get_patterns — view detected cross-project patterns
• pme_detect_drift — check current decisions against existing knowledge

Full tool reference: plugin/skills/SKILL.md

Troubleshooting

No context at session start: Check ~/.pme/worker.pid (worker running) and ~/.pme/projects.db (project bootstrapped). Reinstall with claude plugin install pme@pme-marketplace.

No captures appearing: Captures require messages with decision/learning/constraint signals ("we decided to...", "turns out...", "must always..."). Short or generic messages are intentionally skipped.

Project not recognized: Worker auto-bootstraps on first visit. Symlinked or temp paths may not match — cd to the real path. Check ~/.pme/projects.db for existing entries if the project was previously created under a different path.

Architecture

~/.pme/
  projects.db     # SQLite database (all projects)
  cache/          # Primer cache, dirty files
  worker.pid      # Worker process info

Development

git clone <repo-url>
npm install
npm run build       # Compile TypeScript + sync plugin version
npm test            # Run test suite (971+ tests)
npm run test:watch  # Watch mode
npm run dev         # Run with tsx (dev mode)

License

MIT