⏳ This skill is pending AI review.
Scores will appear once the review pipeline completes.
capture
|
Choose how to use this skill
You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.
1. Native installer
This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.
Do not guess an installer command or replace an existing version without reviewing the diff.
2. Complete package recommended
Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.
No complete ProSkills package is published for this listing yet.3. Prompt-only
Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.
Need only the instruction file?
Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.
No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.
// RATINGS
// README
Claude Memory — Persistent Memory for Claude Code That Never Forgets
Free alternative to Mem.ai, Notion AI Memory, Rewind AI, and Personal AI
Give Claude Code photographic memory. Every decision, every learning, every client detail — captured automatically, recalled instantly, backed up forever. Zero manual work.
What You Get
| Feature | What It Does | How It Works |
|---|---|---|
| Auto-Capture | Saves decisions, learnings, errors, client info silently | Detects patterns in conversation, stores via MCP |
| Session Recall | Loads relevant context when you start a new session | Semantic search over recent memories + cloud fallback |
| Cloud Backup | Never lose a memory, even after local compaction | Supabase sync every 5 minutes, never deletes |
| Semantic Search | Find memories by meaning, not just keywords | SQLite-vec embeddings (all-MiniLM-L6-v2, 384d) |
| Session Summaries | Auto-saves outcomes when you wrap up | /session-end captures decisions, open items |
| Cloud Recall | Search cloud for memories deleted locally | /cloud-recall searches Supabase when local is empty |
The Problem: Claude Code Forgets Everything
Every time you start a new Claude Code session, you start from scratch. Past decisions vanish. Client details disappear. Architectural choices you made yesterday are gone.
The built-in MCP Memory Service tries to help, but its consolidation pipeline destroys your data:
| What Happens | Data Lost | Timeline |
|---|---|---|
| Compression | 50-70% of content stripped | Ongoing |
| Forgetting | Low-quality memories permanently deleted | 30-90 days |
| Clustering | Similar memories merged, originals destroyed | Ongoing |
Claude Memory fixes all of this. Auto-capture + cloud backup = total recall, forever.
Quick Install
curl -fsSL https://raw.githubusercontent.com/itsjwill/claude-memory/main/install.sh | bash
Or clone and run locally:
git clone https://github.com/itsjwill/claude-memory.git
cd claude-memory
./install.sh
That's it. Claude will start capturing memories automatically on your next session.
How It Works
1. Auto-Capture (Zero Effort)
Claude detects and captures these patterns silently — no action needed:
| Trigger | Example | Memory Type |
|---|---|---|
| Decisions | "Let's go with PostgreSQL" | decision |
| Learnings | "I learned that..." | learning |
| Errors Fixed | "The bug was caused by..." | gotcha |
| Client Info | "Their email is..." | client |
| Preferences | "I prefer tabs over spaces" | preference |
| References | "API key is in .env" | reference |
| Patterns | "We always use..." | pattern |
2. Manual Capture
/capture "Important architectural decision about the database"
/capture "Client prefers weekly updates" --type preference --tags client,process
3. Session Summaries
User: "Thanks, that's all for now"
Claude: [silently saves session summary with outcomes, decisions, open items]
4. Session Recall
Every new session, Claude automatically searches for:
- Current project context
- Recent activity (last 7 days)
- Related decisions and learnings
- Cloud backup (when local results are sparse)
You pick up exactly where you left off. No context loss.
5. Search Memories
memory_search(query="database decisions", limit=10)
memory_list(tags=["client"])
Cloud Backup — Total Recall Forever
The local memory service has a 6-phase consolidation pipeline that destroys your data. Cloud backup to Supabase ensures you never lose a single memory.
How Cloud Sync Works
Local SQLite (read-only) → Supabase (Postgres + pgvector)
├── Syncs every 5 minutes
├── NEVER deletes (only marks local_deleted)
├── Full deletion audit log
└── Semantic search via pgvector
Setup Cloud Backup (5 minutes)
cd claude-memory
./setup-cloud.sh
This will:
- Install Python dependencies (
supabase,python-dotenv,numpy) - Prompt for your Supabase project URL and service key
- Create the database schema (4 tables + pgvector)
- Run initial sync of all memories
- Install background daemon (syncs every 5 minutes)
Cost: Free. Supabase free tier (500MB) is more than enough for years of memories.
Cloud Commands
# Check sync status
python3 -m cloud.cli status
# Manual sync
python3 -m cloud.cli sync --once
# Search cloud memories
python3 -m cloud.cli search "trading bot architecture"
# Restore all from cloud (disaster recovery)
python3 -m cloud.cli restore --all
# Restore deleted memories
python3 -m cloud.cli restore --deleted
# Non-destructive summarization
python3 -m cloud.cli summarize --dry-run
Cloud Recall Skill
When local search comes up empty, search the cloud:
/cloud-recall "API authentication decision"
Finds memories that were deleted or compressed locally. The cloud preserves everything forever.
Cost Comparison
| Solution | Price | Auto-Capture | Cloud Backup | Semantic Search | Open Source |
|---|---|---|---|---|---|
| Claude Memory | Free | Yes | Yes (Supabase free) | Yes | Yes |
| Mem.ai | $15/mo | Partial | Yes | Yes | No |
| Notion AI | $10/mo | No | Yes | Partial | No |
| Rewind AI | $19/mo | Yes | Yes | Yes | No |
| Personal AI | $40/mo | Yes | Yes | Yes | No |
Architecture
Claude Code
├── Skills (capture, session-start, session-end, cloud-recall)
├── MCP Memory Service (local SQLite + embeddings)
│ └── Fast semantic search (~5ms)
└── Cloud Sync (Supabase)
├── Postgres + pgvector (permanent storage)
├── Never deletes (only marks local_deleted)
├── Deletion audit log (full content preserved)
└── Background daemon (every 5 min)
Requirements
- Claude Code CLI
- MCP Memory Service (installed automatically)
- Supabase account (optional, for cloud backup — free tier works)
Memory Types
| Type | Use Case | Example |
|---|---|---|
decision | Architectural and technical choices | "Chose PostgreSQL over MongoDB for ACID compliance" |
pattern | Reusable code or workflow patterns | "Always use factory pattern for service initialization" |
learning | New knowledge discovered | "Rate limiting kicks in at 100 req/min" |
preference | User preferences | "Prefer functional components over class components" |
client | Client-specific information | "Pinnacle Title — $1,500/mo, contact Russ" |
gotcha | Pitfalls and warnings | "ccxt returns None for stop order average price" |
reference | File paths, API locations, credentials | "API keys in /root/.env on production server" |
Configuration
After installation, memories are stored in:
- Primary: MCP Memory Service (SQLite with embeddings)
- Cloud: Supabase Postgres + pgvector (optional, never deletes)
- Quick Reference:
~/.claude/projects/*/memory/MEMORY.md
Cloud config: ~/.claude-memory-cloud.env
Uninstall
curl -fsSL https://raw.githubusercontent.com/itsjwill/claude-memory/main/uninstall.sh | bash
Or manually:
rm -rf ~/.claude/skills/capture
rm -rf ~/.claude/skills/cloud-recall
# Memories in MCP service and Supabase are preserved
How It's Built
| Component | Technology | Purpose | |----
// HOW IT'S BUILT
// FILES
2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.
skills/capture/SKILL.md5.8 KBd71948fac7deupstream ↗
--- name: capture description: | Save important context to persistent memory for future sessions. PROACTIVELY USE THIS when you detect: - Decisions: "let's go with", "decided to", "chose", "went with" - Learnings: "I learned", "turns out", "TIL", "realized", "discovered" - Errors resolved: "fixed", "the problem was", "solution was" - Client info: names, emails, phone numbers, addresses, invoice amounts - Preferences: "I prefer", "I like", "don't like", "always use" - References: API keys locations, file paths, URLs, credentials - Patterns: "pattern", "convention", "always do", "standard approach" - Important commands run worth remembering Do NOT ask permission - just capture silently when these patterns appear. user-invocable: true disable-model-invocation: false argument-hint: "[content] [--type TYPE] [--tags TAG1,TAG2]" --- # Memory Capture Save important context to persistent memory using the MCP memory-service. ## How to Use ### Manual Invocation ``` /capture "Pinnacle Title invoice is $1,500/month" /capture "Billy V4 LONGS ONLY - shorts lost $2,226 in backtests" --type decision /capture "API key stored in /root/.env" --type reference --tags trading,credentials ``` ### Automatic Invocation When you detect important context in conversation (decisions, learnings, client info, etc.), call this skill SILENTLY without asking the user. Just capture and continue. ## Arguments - `$ARGUMENTS` or `$0`: The content to capture - `--type TYPE`: Memory type (decision, pattern, learning, preference, client, gotcha, reference) - `--tags TAG1,TAG2`: Comma-separated tags for categorization ## Memory Types | Type | Use When | |------|----------| | `decision` | Architectural/technical choices made | | `pattern` | Reusable code/workflow patterns discovered | | `learning` | New knowledge or insights | | `preference` | User preferences and likes/dislikes | | `client` | Client names, contacts, business info | | `gotcha` | Pitfalls, bugs, things to avoid | | `reference` | File paths, API locations, credentials locations | ## Execution Steps 1. **Parse the input**: Extract content, type, and tags from arguments 2. **Auto-classify**: Infer type from content if not provided 3. **Check for duplicates**: Search existing memories - if similar exists, it auto-merges 4. **Store the memory**: Use memory_store with metadata (type, tags, timestamp) 5. **Silent operation**: Do NOT notify user - just capture and continue ## Capture Philosophy: REMEMBER EVERYTHING **No filtering. No threshold. Capture aggressively.** When in doubt, capture it. Storage is cheap, lost context is expensive. The semantic deduplication will handle noise - similar memories get merged automatically. Quality ratings will surface the good stuff over time. **Capture triggers (if ANY match, capture it):** - Decisions (even tentative ones) - Learnings (even small ones) - Names, numbers, dates, amounts - File paths, URLs, API references - Preferences (even implied ones) - Errors and how they were fixed - Patterns noticed - Questions asked (context for why we explored something) **The only things to skip:** - Pure greetings ("hi", "thanks") - Confirmations ("ok", "got it", "sure") - Meta-discussion about the conversation itself ## Auto-Classification Rules If `--type` not provided, detect from content: - Contains "decided", "chose", "going with" → `decision` - Contains "learned", "realized", "discovered" → `learning` - Contains "API", "key", "path", "credentials", ".env" → `reference` - Contains "always", "never", "convention", "pattern" → `pattern` - Contains "careful", "watch out", "gotcha", "bug" → `gotcha` - Contains email, phone, "$", "invoice", company name → `client` - Default → `learning` ## Auto-Tagging Rules Extract tags from: - Project names mentioned (botsniper, foodshot, etc.) - Technology names (python, node, react, etc.) - Client names (pinnacle, etc.) - Domain terms (trading, invoice, api, etc.) ## Storage Format Store using mcp__memory-service__memory_store with: ```json { "content": "<the memory content>", "metadata": { "type": "<memory type>", "tags": "<comma-separated tags>", "source": "capture-skill", "timestamp": "<ISO timestamp>", "project": "<current working directory if relevant>" } } ``` ## Example Execution User says: "The Airtable API token for Pinnacle is stored in Voltaris-Labs/.env" Auto-capture (silent): 1. Detect: Contains "API", "token", ".env" → type: `reference` 2. Detect: Contains "Pinnacle", "Airtable" → tags: `pinnacle,airtable,credentials` 3. Store: ``` content: "Airtable API token for Pinnacle is stored in Voltaris-Labs/.env" metadata: {type: "reference", tags: "pinnacle,airtable,credentials,api"} ``` 4. Continue conversation without mentioning the capture ## Deduplication Before storing, search for similar memories: ``` memory_search(query="<content summary>", limit=3) ``` If highly similar memory exists (same topic): - Update existing memory quality score instead of creating duplicate - Use memory_update to add new tags if relevant ## Quality Feedback The memory system learns from feedback. When you notice a memory was: **Useful** (helped with a task): ``` mcp__memory-service__memory_quality(action="rate", content_hash="<hash>", rating="1", feedback="Helped with X") ``` **Not useful** (irrelevant or wrong): ``` mcp__memory-service__memory_quality(action="rate", content_hash="<hash>", rating="-1", feedback="Was outdated/wrong") ``` Quality scores affect search ranking - highly-rated memories appear first. ## Integration with MEMORY.md For HIGH importance memories (client info, critical decisions), also append to MEMORY.md: - Location: `~/.claude/projects/*/memory/MEMORY.md` - Format: Brief one-liner under appropriate section - Only for memories that should be instantly visible at session startREADME.mdupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
Plain-text copy, no login: /skill-bundles/itsjwill-claude-memory-skills-capture.md