⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

capture

itsjwill@itsjwill⭐ 15 stars· last commit 9mo ago· 0 open issues

|

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.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐ 15 on GitHubGitHub ↗

Growing

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

Claude Memory — Persistent Memory for Claude Code That Never Forgets

Stars License: MIT Updated Claude Code

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

FeatureWhat It DoesHow It Works
Auto-CaptureSaves decisions, learnings, errors, client info silentlyDetects patterns in conversation, stores via MCP
Session RecallLoads relevant context when you start a new sessionSemantic search over recent memories + cloud fallback
Cloud BackupNever lose a memory, even after local compactionSupabase sync every 5 minutes, never deletes
Semantic SearchFind memories by meaning, not just keywordsSQLite-vec embeddings (all-MiniLM-L6-v2, 384d)
Session SummariesAuto-saves outcomes when you wrap up/session-end captures decisions, open items
Cloud RecallSearch 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 HappensData LostTimeline
Compression50-70% of content strippedOngoing
ForgettingLow-quality memories permanently deleted30-90 days
ClusteringSimilar memories merged, originals destroyedOngoing

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:

TriggerExampleMemory 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:

  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

# 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

SolutionPriceAuto-CaptureCloud BackupSemantic SearchOpen Source
Claude MemoryFreeYesYes (Supabase free)YesYes
Mem.ai$15/moPartialYesYesNo
Notion AI$10/moNoYesPartialNo
Rewind AI$19/moYesYesYesNo
Personal AI$40/moYesYesYesNo

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

Memory Types

TypeUse CaseExample
decisionArchitectural and technical choices"Chose PostgreSQL over MongoDB for ACID compliance"
patternReusable code or workflow patterns"Always use factory pattern for service initialization"
learningNew knowledge discovered"Rate limiting kicks in at 100 req/min"
preferenceUser preferences"Prefer functional components over class components"
clientClient-specific information"Pinnacle Title — $1,500/mo, contact Russ"
gotchaPitfalls and warnings"ccxt returns None for stop order average price"
referenceFile 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 start
    
  • README.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

// REPO STATS

15 stars
0 open issues
Last commit: 9mo ago