# capture

Adopt this skill: https://proskills.md/skills/other/itsjwill-claude-memory-skills-capture

Page: https://proskills.md/skills/other/itsjwill-claude-memory-skills-capture
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/capture/SKILL.md
size: 5897
sha: d71948fac7defc39755c7db42eba2f318e77e0a6
upstream: https://github.com/itsjwill/claude-memory/blob/main/skills/capture/SKILL.md

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

## File: README.md
upstream: https://github.com/itsjwill/claude-memory/blob/main/README.md

````text
# Claude Memory — Persistent Memory for Claude Code That Never Forgets

[![Stars](https://img.shields.io/github/stars/itsjwill/claude-memory?style=social)](https://github.com/itsjwill/claude-memory)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
[![Updated](https://img.shields.io/badge/Updated-2026-blue.svg)]()
[![Claude Code](https://img.shields.io/badge/Claude_Code-Compatible-blueviolet.svg)]()

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

```bash
curl -fsSL https://raw.githubusercontent.com/itsjwill/claude-memory/main/install.sh | bash
```

Or clone and run locally:

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

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

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

```bash
cd claude-memory
./setup-cloud.sh
```

This will:
1. Install Python dependencies (`supabase`, `python-dotenv`, `numpy`)
2. Prompt for your Supabase project URL and service key
3. Create the database schema (4 tables + pgvector)
4. Run initial sync of all memories
5. Install background daemon (syncs every 5 minutes)

**Cost:** Free. Supabase free tier (500MB) is more than enough for years of memories.

### Cloud Commands

```bash
# 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](https://claude.ai/code) CLI
- [MCP Memory Service](https://github.com/doobidoo/mcp-memory-service) (installed automatically)
- [Supabase](https://supabase.com) 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

```bash
curl -fsSL https://raw.githubusercontent.com/itsjwill/claude-memory/main/uninstall.sh | bash
```

Or manually:

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