superlocalmemory 2.6.5 → 2.7.1

package/CHANGELOG.md

@@ -16,6 +16,63 @@ SuperLocalMemory V2 - Intelligent local memory system for AI coding assistants.
 
 ---
 
+## [2.7.1] - 2026-02-16
+
+### Added
+- **Learning Dashboard Tab** — New "Learning" tab in the web dashboard showing ranking phase, tech preferences, workflow patterns, source quality, engagement health, and privacy controls
+- **Learning API Routes** — `/api/learning/status`, `/api/learning/reset`, `/api/learning/retrain` endpoints for the dashboard
+- **One-click Reset** — Reset all learning data directly from the dashboard UI
+
+---
+
+## [2.7.0] - 2026-02-16
+
+**Release Type:** Major Feature Release — "Your AI Learns You"
+
+SuperLocalMemory now learns your patterns, adapts to your workflow, and personalizes recall. All processing happens 100% locally — your behavioral data never leaves your machine. GDPR Article 17 compliant by design.
+
+### Added
+- **Adaptive Learning System** — Three-layer learning architecture that detects tech preferences, project context, and workflow patterns across all your projects
+- **Personalized Recall Ranking** — Search results re-ranked using learned patterns. Three-phase adaptive system: baseline → rule-based → ML (LightGBM LambdaRank)
+- **Synthetic Bootstrap** — ML model works from day 1 by bootstrapping from existing memory patterns. No cold-start degradation.
+- **Multi-Channel Feedback** — Tell the system which memories were useful via MCP (`memory_used`), CLI (`slm useful`), or dashboard clicks
+- **Source Quality Scoring** — Learns which tools produce the most useful memories using Beta-Binomial Bayesian scoring
+- **Workflow Pattern Detection** — Detects your coding workflow sequences (e.g., docs → architecture → code → test) using time-weighted sliding-window mining
+- **Local Engagement Metrics** — Track memory system health locally with zero telemetry (`slm engagement`)
+- **Separate Learning Database** — Behavioral data in `learning.db`, isolated from `memory.db`. One-command erasure: `slm learning reset`
+- **3 New MCP Tools** — `memory_used` (feedback signal), `get_learned_patterns` (transparency), `correct_pattern` (user control)
+- **2 New MCP Resources** — `memory://learning/status`, `memory://engagement`
+- **New CLI Commands** — `slm useful`, `slm learning status/retrain/reset`, `slm engagement`, `slm patterns correct`
+- **New Skill** — `slm-show-patterns` for viewing learned preferences in Claude Code and compatible tools
+- **Auto Python Installation** — `install.sh` now auto-installs Python 3 on macOS (Homebrew/Xcode) and Linux (apt/dnf) for new users
+- **319 Tests** — 229 unit tests + 13 E2E + 14 regression + 19 fresh-install + 42 edge-case tests
+
+### Research Foundations
+- Two-stage BM25 → re-ranker pipeline (eKNOW 2025)
+- LightGBM LambdaRank pairwise ranking (Burges 2010, MO-LightGBM SIGIR 2025)
+- Three-phase cold-start mitigation (LREC 2024)
+- Time-weighted sequence mining (TSW-PrefixSpan, IEEE 2020)
+- Bayesian temporal confidence (MACLA, arXiv:2512.18950)
+- Privacy-preserving zero-communication feedback design
+
+### Changed
+- **MCP Tools** — Now 12 tools (was 9), 6 resources (was 4), 2 prompts
+- **Skills** — Now 7 universal skills (was 6)
+- **install.sh** — Auto-installs Python if missing, installs learning deps automatically
+- **DMG Installer** — Updated to v2.7.0 with learning modules
+
+### Dependencies (Optional)
+- `lightgbm>=4.0.0` — ML ranking (auto-installed, graceful fallback if unavailable)
+- `scipy>=1.9.0` — Statistical functions (auto-installed, graceful fallback if unavailable)
+
+### Performance
+- Re-ranking adds <15ms latency to recall queries
+- Learning DB typically <1MB for 1,000 memories
+- Bootstrap model trains in <30 seconds for 1,000 memories
+- All BM1-BM6 benchmarks: no regression >10%
+
+---
+
 ## [2.6.5] - 2026-02-16
 
 ### Added

package/README.md

@@ -44,22 +44,89 @@
 
 ---
 
-## What's New in v2.6.5
+## What's New in v2.7 — "Your AI Learns You"
 
-**Interactive Knowledge Graph** — Your memories, visually connected. Powered by [Cytoscape.js](https://js.cytoscape.org/) (the same library behind Obsidian's graph plugins):
+**SuperLocalMemory now learns your patterns, adapts to your workflow, and personalizes recall — all 100% locally on your machine.** No cloud. No LLM. Your behavioral data never leaves your device.
 
-- 🔍 **Zoom, pan, explore** — Mouse wheel to zoom, drag to pan, smooth navigation
-- 👆 **Click nodes** — Opens memory preview with "View Full Memory", "Expand Neighbors", "Filter to Cluster"
-- 🎨 **6 layout algorithms** — Force-directed (physics-based), circular, grid, hierarchical, concentric, breadthfirst
-- 🔗 **Smart filtering** — Click cluster cards or entity badges → graph instantly updates
-- ⚡ **Performance** — 3-tier rendering strategy handles 10,000+ nodes smoothly
+### Adaptive Learning System
 
-Launch the dashboard: `python3 ~/.claude-memory/ui_server.py` → `http://localhost:8765/graph.html`
+Your memory system evolves with you through three learning layers:
 
-**[[Complete Interactive Graph Guide →|Using-Interactive-Graph]]**
+| Layer | What It Learns | How |
+|-------|---------------|-----|
+| **Tech Preferences** | "You prefer FastAPI over Django" (83% confidence) | Cross-project frequency analysis with Bayesian scoring |
+| **Project Context** | Detects your active project from 4 signals | Path analysis, tags, profile, content clustering |
+| **Workflow Patterns** | "You typically: docs → architecture → code → test" | Time-weighted sliding-window sequence mining |
+
+### Three-Phase Adaptive Ranking
+
+Recall results get smarter over time — automatically:
+
+1. **Phase 1 (Baseline):** Standard search — same as v2.6
+2. **Phase 2 (Rule-Based):** After ~20 feedback signals — boosts results matching your preferences
+3. **Phase 3 (ML Ranking):** After ~200 signals — LightGBM LambdaRank re-ranks with 9 personalized features
+
+### Privacy by Design — GDPR Compliant
+
+| Concern | SuperLocalMemory v2.7 | Cloud-Based Alternatives |
+|---------|----------------------|--------------------------|
+| **Where is learning data?** | `~/.claude-memory/learning.db` on YOUR machine | Their servers, their terms |
+| **Who processes your behavior?** | Local gradient boosting (no LLM, no GPU) | Cloud LLMs process your data |
+| **Right to erasure (GDPR Art. 17)?** | `slm learning reset` — one command, instant | Submit a request, wait weeks |
+| **Data portability?** | Copy the SQLite file | Vendor lock-in |
+| **Telemetry?** | Zero. Absolutely none. | Usage analytics, behavior tracking |
+
+**Your learning data is stored separately from your memories.** Delete `learning.db` and your memories are untouched. Delete `memory.db` and your learning patterns are untouched. Full data sovereignty.
+
+### Research-Backed Architecture
+
+Every component is grounded in peer-reviewed research, adapted for local-first operation:
+
+| Component | Research Basis |
+|-----------|---------------|
+| Two-stage retrieval pipeline | BM25 → re-ranker (eKNOW 2025) |
+| Adaptive cold-start ranking | Hierarchical meta-learning (LREC 2024) |
+| Time-weighted sequence mining | TSW-PrefixSpan (IEEE 2020) |
+| Bayesian confidence scoring | MACLA (arXiv:2512.18950) |
+| LightGBM LambdaRank | Pairwise ranking (Burges 2010, MO-LightGBM SIGIR 2025) |
+| Privacy-preserving feedback | Zero-communication design — stronger than differential privacy (ADPMF, IPM 2024) |
+
+### New MCP Tools
+
+| Tool | Purpose |
+|------|---------|
+| `memory_used` | Tell the AI which recalled memories were useful — trains the ranking model |
+| `get_learned_patterns` | See what the system has learned about your preferences |
+| `correct_pattern` | Fix a wrong pattern — your correction overrides with maximum confidence |
+
+### New CLI Commands
+
+```bash
+slm useful 42 87           # Mark memories as useful (ranking feedback)
+slm patterns list           # See learned tech preferences
+slm learning status         # Learning system diagnostics
+slm learning reset          # Delete all behavioral data (memories preserved)
+slm engagement              # Local engagement health metrics
+```
+
+**Upgrade:** `npm install -g superlocalmemory@latest` — Learning dependencies install automatically.
+
+[Learning System Guide →](https://github.com/varun369/SuperLocalMemoryV2/wiki/Learning-System) | [Upgrade Guide →](https://github.com/varun369/SuperLocalMemoryV2/wiki/Upgrading-to-v2.7) | [Full Changelog](CHANGELOG.md)
 
 ---
 
+<details>
+<summary><strong>Previous: v2.6.5 — Interactive Knowledge Graph</strong></summary>
+
+- Fully interactive visualization with zoom, pan, click-to-explore (Cytoscape.js)
+- 6 layout algorithms, smart cluster filtering, 10,000+ node performance
+- Mobile & accessibility support: touch gestures, keyboard nav, screen reader
+
+</details>
+
+<details>
+<summary><strong>Previous: v2.6 — Security & Scale</strong></summary>
+
 ## What's New in v2.6
 
 SuperLocalMemory is now **production-hardened** with security, performance, and scale improvements:
@@ -76,6 +143,8 @@ SuperLocalMemory is now **production-hardened** with security, performance, and
 
 [Interactive Architecture Diagram](https://superlocalmemory.com/architecture.html) | [Architecture Doc](docs/ARCHITECTURE-V2.5.md) | [Full Changelog](CHANGELOG.md)
 
+</details>
+
 ---
 
 ## The Problem
@@ -165,14 +234,18 @@ python3 ~/.claude-memory/ui_server.py
 
 ### Built on 2026 Research
 
-Not another simple key-value store. SuperLocalMemory implements **cutting-edge memory architecture**:
+Not another simple key-value store. SuperLocalMemory implements **cutting-edge memory architecture** backed by peer-reviewed research:
 
 - **PageIndex** (Meta AI) → Hierarchical memory organization
 - **GraphRAG** (Microsoft) → Knowledge graph with auto-clustering
 - **xMemory** (Stanford) → Identity pattern learning
 - **A-RAG** → Multi-level retrieval with context awareness
+- **LambdaRank** (Burges 2010, MO-LightGBM SIGIR 2025) → Adaptive re-ranking *(v2.7)*
+- **TSW-PrefixSpan** (IEEE 2020) → Time-weighted workflow pattern mining *(v2.7)*
+- **MACLA** (arXiv:2512.18950) → Bayesian temporal confidence scoring *(v2.7)*
+- **FCS** (LREC 2024) → Hierarchical cold-start mitigation *(v2.7)*
 
-**The only open-source implementation combining all four approaches.**
+**The only open-source implementation combining all eight approaches — entirely locally.**
 
 [See research citations →](https://github.com/varun369/SuperLocalMemoryV2/wiki/Research-Foundations)
 
@@ -197,11 +270,16 @@ Not another simple key-value store. SuperLocalMemory implements **cutting-edge m
 │  17+ IDEs with single database                              │
 ├─────────────────────────────────────────────────────────────┤
 │  Layer 6: MCP INTEGRATION                                   │
-│  Model Context Protocol: 6 tools, 4 resources, 2 prompts    │
+│  Model Context Protocol: 12 tools, 6 resources, 2 prompts   │
 │  Auto-configured for Cursor, Windsurf, Claude               │
 ├─────────────────────────────────────────────────────────────┤
+│  Layer 5½: ADAPTIVE LEARNING (v2.7 — NEW)                   │
+│  Three-layer learning: tech prefs + project context + flow  │
+│  LightGBM LambdaRank re-ranking (fully local, no cloud)    │
+│  Research: eKNOW 2025, MACLA, TSW-PrefixSpan, LREC 2024    │
+├─────────────────────────────────────────────────────────────┤
 │  Layer 5: SKILLS LAYER                                      │
-│  6 universal slash-commands for AI assistants               │
+│  7 universal slash-commands for AI assistants               │
 │  Compatible with Claude Code, Continue, Cody                │
 ├─────────────────────────────────────────────────────────────┤
 │  Layer 4: PATTERN LEARNING + MACLA                          │
@@ -224,6 +302,7 @@ Not another simple key-value store. SuperLocalMemory implements **cutting-edge m
 
 ### Key Capabilities
 
+- **[Adaptive Learning System](https://github.com/varun369/SuperLocalMemoryV2/wiki/Learning-System)** — Learns your tech preferences, workflow patterns, and project context. Personalizes recall ranking using local ML (LightGBM). Zero cloud dependency. *New in v2.7*
 - **[Knowledge Graphs](https://github.com/varun369/SuperLocalMemoryV2/wiki/Knowledge-Graph)** — Automatic relationship discovery. Interactive visualization with zoom, pan, click.
 - **[Pattern Learning](https://github.com/varun369/SuperLocalMemoryV2/wiki/Pattern-Learning)** — Learns your coding preferences and style automatically.
 - **[Multi-Profile Support](https://github.com/varun369/SuperLocalMemoryV2/wiki/Using-Memory-Profiles)** — Isolated contexts for work, personal, clients. Zero context bleeding.
@@ -302,14 +381,18 @@ Not another simple key-value store. SuperLocalMemory implements **cutting-edge m
 | **Universal CLI** | ❌ | ❌ | ❌ | ❌ | ✅ |
 | **Multi-Layer Architecture** | ❌ | ❌ | ❌ | ❌ | ✅ |
 | **Pattern Learning** | ❌ | ❌ | ❌ | ❌ | ✅ |
+| **Adaptive ML Ranking** | Cloud LLM | ❌ | ❌ | ❌ | ✅ **Local ML** |
 | **Knowledge Graphs** | ✅ | ✅ | ❌ | ❌ | ✅ |
 | **100% Local** | ❌ | ❌ | Partial | Partial | ✅ |
+| **GDPR by Design** | ❌ | ❌ | ❌ | ❌ | ✅ |
 | **Zero Setup** | ❌ | ❌ | ❌ | ❌ | ✅ |
 | **Completely Free** | Limited | Limited | Partial | ✅ | ✅ |
 
 **SuperLocalMemory V2 is the ONLY solution that:**
+- ✅ **Learns and adapts** locally — no cloud LLM needed for personalization
 - ✅ Works across 17+ IDEs and CLI tools
 - ✅ Remains 100% local (no cloud dependencies)
+- ✅ GDPR Article 17 compliant — one-command data erasure
 - ✅ Completely free with unlimited memories
 
 [See full competitive analysis →](docs/COMPETITIVE-ANALYSIS.md)

package/bin/slm

@@ -121,13 +121,178 @@ case "$1" in
             context)
                 python3 "$SLM_DIR/pattern_learner.py" context "$@"
                 ;;
+            correct)
+                # slm patterns correct <id> <new_value>
+                pattern_id="$1"
+                new_value="$2"
+                if [ -z "$pattern_id" ] || [ -z "$new_value" ]; then
+                    echo "Usage: slm patterns correct <pattern_id> <new_value>"
+                    exit 1
+                fi
+                python3 -c "
+import sys
+sys.path.insert(0, '${SLM_DIR}')
+sys.path.insert(0, '$(dirname "${SLM_DIR}")/Documents/AGENTIC_Official/SuperLocalMemoryV2-repo/src')
+try:
+    from learning import get_learning_db
+    ldb = get_learning_db()
+    if ldb:
+        conn = ldb._get_connection()
+        cursor = conn.cursor()
+        cursor.execute('SELECT * FROM transferable_patterns WHERE id = ?', (int(sys.argv[1]),))
+        p = cursor.fetchone()
+        conn.close()
+        if p:
+            ldb.upsert_transferable_pattern(
+                pattern_type=p['pattern_type'], key=p['key'],
+                value=sys.argv[2], confidence=1.0,
+                evidence_count=p['evidence_count']+1,
+                profiles_seen=p['profiles_seen'],
+                contradictions=[f\"Corrected from '{p['value']}' to '{sys.argv[2]}'\"],
+            )
+            print(f\"Pattern '{p['key']}' corrected: '{p['value']}' -> '{sys.argv[2]}'\")
+        else:
+            print(f'Pattern #{sys.argv[1]} not found')
+    else:
+        print('Learning database not available')
+except ImportError:
+    print('Learning features not available')
+except Exception as e:
+    print(f'Error: {e}')
+" "$pattern_id" "$new_value"
+                ;;
             *)
-                echo "Usage: slm patterns {update|list|context}"
+                echo "Usage: slm patterns {update|list|context|correct}"
                 exit 1
                 ;;
         esac
         ;;
 
+    useful)
+        shift
+        # Mark memory IDs as useful (v2.7 learning feedback)
+        if [ -z "$1" ]; then
+            echo "Usage: slm useful <memory_id> [memory_id...]"
+            echo "  Mark recalled memories as useful to improve future ranking"
+            exit 1
+        fi
+        python3 -c "
+import sys
+sys.path.insert(0, '${SLM_DIR}')
+sys.path.insert(0, '$(dirname \"${SLM_DIR}\")/Documents/AGENTIC_Official/SuperLocalMemoryV2-repo/src')
+try:
+    from learning.feedback_collector import FeedbackCollector
+    fc = FeedbackCollector()
+    ids = [int(x) for x in sys.argv[1:]]
+    fc.record_cli_useful(ids, query='cli-feedback')
+    print(f'Marked {len(ids)} memor{\"y\" if len(ids)==1 else \"ies\"} as useful')
+except ImportError:
+    print('Learning features not available. Install: pip3 install lightgbm scipy')
+except Exception as e:
+    print(f'Error: {e}')
+" "$@"
+        ;;
+
+    learning)
+        shift
+        subcommand="${1:-status}"
+        shift 2>/dev/null || true
+        case "$subcommand" in
+            status)
+                python3 -c "
+import sys, json
+sys.path.insert(0, '${SLM_DIR}')
+sys.path.insert(0, '$(dirname \"${SLM_DIR}\")/Documents/AGENTIC_Official/SuperLocalMemoryV2-repo/src')
+try:
+    from learning import get_status
+    status = get_status()
+    print('SuperLocalMemory v2.7 — Learning System Status')
+    print('=' * 50)
+    deps = status['dependencies']
+    print(f'LightGBM:  {\"installed (\" + deps[\"lightgbm\"][\"version\"] + \")\" if deps[\"lightgbm\"][\"installed\"] else \"not installed\"}')
+    print(f'SciPy:     {\"installed (\" + deps[\"scipy\"][\"version\"] + \")\" if deps[\"scipy\"][\"installed\"] else \"not installed\"}')
+    print(f'ML Ranking:  {\"available\" if status[\"ml_ranking_available\"] else \"unavailable\"}')
+    print(f'Full Learning: {\"available\" if status[\"learning_available\"] else \"unavailable\"}')
+    if status.get('learning_db_stats'):
+        s = status['learning_db_stats']
+        print(f'')
+        print(f'Feedback signals: {s[\"feedback_count\"]}')
+        print(f'Unique queries:   {s[\"unique_queries\"]}')
+        print(f'Patterns learned: {s[\"transferable_patterns\"]} ({s[\"high_confidence_patterns\"]} high confidence)')
+        print(f'Workflow patterns: {s[\"workflow_patterns\"]}')
+        print(f'Sources tracked:  {s[\"tracked_sources\"]}')
+        print(f'Models trained:   {s[\"models_trained\"]}')
+        print(f'Learning DB size: {s[\"db_size_kb\"]} KB')
+except ImportError:
+    print('Learning features not available. Install: pip3 install lightgbm scipy')
+except Exception as e:
+    print(f'Error: {e}')
+"
+                ;;
+            retrain)
+                python3 -c "
+import sys
+sys.path.insert(0, '${SLM_DIR}')
+sys.path.insert(0, '$(dirname \"${SLM_DIR}\")/Documents/AGENTIC_Official/SuperLocalMemoryV2-repo/src')
+try:
+    from learning import get_adaptive_ranker
+    ranker = get_adaptive_ranker()
+    if ranker:
+        result = ranker.train(force=True)
+        if result:
+            print(f'Model retrained successfully')
+        else:
+            print('Insufficient data for training (need 200+ feedback signals)')
+    else:
+        print('Adaptive ranker not available')
+except ImportError:
+    print('Learning features not available. Install: pip3 install lightgbm scipy')
+except Exception as e:
+    print(f'Error: {e}')
+"
+                ;;
+            reset)
+                python3 -c "
+import sys
+sys.path.insert(0, '${SLM_DIR}')
+sys.path.insert(0, '$(dirname \"${SLM_DIR}\")/Documents/AGENTIC_Official/SuperLocalMemoryV2-repo/src')
+try:
+    from learning import get_learning_db
+    ldb = get_learning_db()
+    if ldb:
+        ldb.reset()
+        print('All learning data reset. Memories in memory.db preserved.')
+    else:
+        print('Learning database not available')
+except ImportError:
+    print('Learning features not available')
+except Exception as e:
+    print(f'Error: {e}')
+"
+                ;;
+            *)
+                echo "Usage: slm learning {status|retrain|reset}"
+                exit 1
+                ;;
+        esac
+        ;;
+
+    engagement)
+        python3 -c "
+import sys
+sys.path.insert(0, '${SLM_DIR}')
+sys.path.insert(0, '$(dirname \"${SLM_DIR}\")/Documents/AGENTIC_Official/SuperLocalMemoryV2-repo/src')
+try:
+    from learning.engagement_tracker import EngagementTracker
+    tracker = EngagementTracker()
+    print(tracker.format_for_cli())
+except ImportError:
+    print('Learning features not available. Install: pip3 install lightgbm scipy')
+except Exception as e:
+    print(f'Error: {e}')
+"
+        ;;
+
     help|--help|-h)
         cat <<EOF
 SuperLocalMemory V2 - Universal CLI
@@ -154,6 +319,14 @@ PATTERN LEARNING:
   slm patterns update      Learn patterns from memories
   slm patterns list [threshold]  List learned patterns
   slm patterns context [threshold]  Get coding identity context
+  slm patterns correct <id> <value>  Correct a learned pattern
+
+LEARNING (v2.7):
+  slm useful <id> [id...]  Mark memories as useful (ranking feedback)
+  slm learning status      Learning system status
+  slm learning retrain     Force model retrain
+  slm learning reset       Delete all learning data (memories preserved)
+  slm engagement           Show engagement metrics
 
 WEB DASHBOARD:
   slm ui [PORT]            Start web dashboard (default port 8765)
@@ -187,13 +360,13 @@ DOCUMENTATION:
   README: https://github.com/varun369/SuperLocalMemoryV2
   Docs: ~/.claude-memory/docs/
 
-VERSION: 2.4.1
+VERSION: 2.7.0
 EOF
         ;;
 
     version|--version|-v)
         echo "SuperLocalMemory V2 - Universal CLI"
-        echo "Version: 2.4.1"
+        echo "Version: 2.7.0"
         echo "Database: $SLM_DIR/memory.db"
         ;;
 
@@ -213,6 +386,9 @@ EOF
         echo "  profile   - Manage profiles"
         echo "  graph     - Knowledge graph operations"
         echo "  patterns  - Pattern learning"
+        echo "  useful    - Mark memories as useful"
+        echo "  learning  - Learning system management"
+        echo "  engagement - Show engagement metrics"
         echo "  help      - Show detailed help"
         echo ""
         echo "Run 'slm help' for more information"

package/bin/superlocalmemoryv2:learning

@@ -0,0 +1,4 @@
+#!/bin/bash
+# SuperLocalMemory V2 - Learning System Status
+SLM_DIR="${HOME}/.claude-memory"
+exec "${SLM_DIR}/bin/slm" learning "${@:-status}"

package/bin/superlocalmemoryv2:patterns

@@ -0,0 +1,4 @@
+#!/bin/bash
+# SuperLocalMemory V2 - Show Learned Patterns
+SLM_DIR="${HOME}/.claude-memory"
+exec "${SLM_DIR}/bin/slm" patterns list "$@"

package/docs/ARCHITECTURE.md

@@ -85,7 +85,7 @@ Simple Storage → Intelligent Organization → Adaptive Learning
 
 The MCP server provides native integration with modern AI tools:
 
-**8 Tools:**
+**12 Tools:**
 - `remember(content, tags, project)` - Save memories
 - `recall(query, limit)` - Search memories
 - `list_recent(limit)` - Recent memories
@@ -94,12 +94,18 @@ The MCP server provides native integration with modern AI tools:
 - `switch_profile(name)` - Change profile
 - `search(query)` - Search memories (OpenAI MCP spec for ChatGPT Connectors)
 - `fetch(id)` - Fetch memory by ID (OpenAI MCP spec for ChatGPT Connectors)
+- `backup_status()` - Auto-backup status
+- `memory_used(memory_id, query, usefulness)` - Feedback for learning (v2.7)
+- `get_learned_patterns(min_confidence, category)` - Retrieve learned patterns (v2.7)
+- `correct_pattern(pattern_id, correct_value)` - Correct a learned pattern (v2.7)
 
-**4 Resources:**
-- `memory://recent` - Recent memories feed
+**6 Resources:**
+- `memory://recent/{limit}` - Recent memories feed
 - `memory://stats` - System statistics
 - `memory://graph/clusters` - Graph clusters
 - `memory://patterns/identity` - Learned patterns
+- `memory://learning/status` - Learning system status (v2.7)
+- `memory://engagement` - Engagement metrics (v2.7)
 
 **2 Prompts:**
 - `coding_identity_prompt` - User's coding style
@@ -221,16 +227,16 @@ SuperLocalMemory V2 uses a hierarchical, additive architecture where each layer
                             ↑
 ┌─────────────────────────────────────────────────────────────────┐
 │ Layer 6: MCP Integration (mcp_server.py)                       │
-│  6 tools, 4 resources, 2 prompts                               │
+│  12 tools, 6 resources, 2 prompts                              │
 │  Auto-configured for Claude Desktop, Cursor, Windsurf, etc.   │
 │  Output: Native AI tool access via Model Context Protocol      │
 └─────────────────────────────────────────────────────────────────┘
                             ↑
 ┌─────────────────────────────────────────────────────────────────┐
 │ Layer 5: Skills Layer (skills/*)                               │
-│  6 slash-command skills for Claude Code, Continue.dev, Cody    │
+│  7 slash-command skills for Claude Code, Continue.dev, Cody    │
 │  slm-remember, slm-recall, slm-status, slm-list-recent,       │
-│  slm-build-graph, slm-switch-profile                           │
+│  slm-build-graph, slm-switch-profile, slm-show-patterns       │
 │  Output: Familiar /command interface across AI tools           │
 └─────────────────────────────────────────────────────────────────┘
                             ↑

package/docs/MCP-MANUAL-SETUP.md

@@ -683,7 +683,7 @@ python3 ~/.claude-memory/mcp_server.py
 ```
 ============================================================
 SuperLocalMemory V2 - MCP Server
-Version: 2.4.1
+Version: 2.7.0
 ============================================================
 
 Transport: stdio
@@ -692,10 +692,16 @@ Database: /Users/yourusername/.claude-memory/memory.db
 MCP Tools Available:
   - remember(content, tags, project, importance)
   - recall(query, limit, min_score)
+  - search(query)          [ChatGPT Connector]
+  - fetch(id)              [ChatGPT Connector]
   - list_recent(limit)
   - get_status()
   - build_graph()
   - switch_profile(name)
+  - backup_status()        [Auto-Backup]
+  - memory_used(...)       [v2.7 Learning]
+  - get_learned_patterns(...)  [v2.7 Learning]
+  - correct_pattern(...)   [v2.7 Learning]
 
 ...
 ```
@@ -731,7 +737,7 @@ In your IDE/app, check:
 
 ## Available MCP Tools
 
-Once configured, these 8 tools are available:
+Once configured, these 12 tools are available:
 
 | Tool | Purpose | Example Usage |
 |------|---------|---------------|
@@ -743,10 +749,14 @@ Once configured, these 8 tools are available:
 | `switch_profile()` | Change profile | "Switch to work profile" |
 | `search()` | Search memories (OpenAI MCP spec) | Used by ChatGPT Connectors and Deep Research |
 | `fetch()` | Fetch memory by ID (OpenAI MCP spec) | Used by ChatGPT Connectors and Deep Research |
+| `backup_status()` | Auto-backup status | "What's the backup status?" |
+| `memory_used()` | Feedback for learning (v2.7) | Implicit — called when a recalled memory is used |
+| `get_learned_patterns()` | Retrieve learned patterns (v2.7) | "What patterns have you learned about me?" |
+| `correct_pattern()` | Correct a learned pattern (v2.7) | "I actually prefer Vue, not React" |
 
-**Note:** `search()` and `fetch()` are required by OpenAI's MCP specification for ChatGPT Connectors. They are available in all transports but primarily used by ChatGPT.
+**Note:** `search()` and `fetch()` are required by OpenAI's MCP specification for ChatGPT Connectors. They are available in all transports but primarily used by ChatGPT. The 3 learning tools (`memory_used`, `get_learned_patterns`, `correct_pattern`) require v2.7's optional learning dependencies.
 
-Plus **2 MCP prompts** and **4 MCP resources** for advanced use.
+Plus **2 MCP prompts** and **6 MCP resources** for advanced use.
 
 ---