varun pratap Bhardwaj

Posted on Feb 12

I Built the Only Local-First Memory for AI Tools (and It's Free Forever)

#ai #opensource #mcp #privacy

The Problem: AI Tools Have Amnesia

Every time you start a new Claude session, you're back to square one:

You: "Remember that authentication bug we fixed last week?"
Claude: "I don't have access to previous conversations..."
You: *sighs and explains everything again*

This happens because AI assistants don't remember anything between sessions.

You waste hours:

Re-explaining your project architecture
Describing your coding preferences
Repeating previous decisions
Losing context when switching between tools (Claude Desktop → Cursor → VS Code)

Existing Solutions: Cloud-Dependent and Expensive

The market offers cloud-based memory services:

Service	Cost	Privacy	Lock-in
Mem0	$24M funding, $50+/month	Sends data to cloud	Vendor lock-in
Zep	$50+/month	Cloud-based	Vendor lock-in
Letta	$40+/month	Cloud-first	Vendor lock-in

Problems:

Your private code goes to their servers
Monthly subscriptions forever
Locked into their ecosystem
Stop paying → lose all your data

My Solution: SuperLocalMemory V2

100% local. Privacy-first. Free forever.

I built a universal memory system that:

Stores everything on YOUR machine
Works with 16+ AI tools simultaneously
Requires zero API keys
Costs nothing
Lets YOU own your data

Architecture: 10 Additive Layers

SuperLocalMemory uses a unique 10-layer architecture. Each layer enhances but never replaces lower layers. The system degrades gracefully if advanced features fail.

Layer 10: A2A Agent Collaboration (planned v2.6)
  └── Agent-to-Agent Protocol for multi-agent coordination
Layer 9: Visualization (ui_server.py)
  └── Interactive web dashboard, timeline, graph explorer
Layer 8: Hybrid Search (src/hybrid_search.py)
  └── Semantic + FTS5 + Graph combined retrieval
Layer 7: Universal Access (MCP + Skills + CLI)
  └── 3 access methods, 16+ IDE integrations
Layer 6: MCP Integration (mcp_server.py)
  └── 6 tools, 4 resources, 2 prompts via Model Context Protocol
Layer 5: Skills Layer (skills/*)
  └── 6 slash-command skills for Claude Code, Continue.dev, Cody, etc.
Layer 4: Pattern Learning (src/pattern_learner.py)
  └── Learns coding preferences, terminology, frameworks
Layer 3: Knowledge Graph (src/graph_engine.py)
  └── TF-IDF entity extraction, hierarchical Leiden clustering
Layer 2: Hierarchical Index (src/tree_manager.py)
  └── Parent-child relationships, breadcrumb navigation
Layer 1: Raw Storage (src/memory_store_v2.py)
  └── SQLite + FTS5 full-text search + TF-IDF vectors

Layer 1: Raw Storage (SQLite + FTS5)

At the foundation: SQLite database with Full-Text Search (FTS5) and TF-IDF vectors.

# Core storage with FTS5 index
cursor.execute('''
    CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts
    USING fts5(content, tags, tokenize="porter unicode61")
''')

Why SQLite?

Zero configuration
Embedded (no separate server)
ACID compliant
Battle-tested reliability
Cross-platform

Layer 2: Hierarchical Index

Memories can have parent-child relationships, creating a navigable tree structure.

slm remember "Project: E-commerce platform" --parent 0
slm remember "Authentication uses JWT tokens" --parent 42
slm remember "JWT secret rotation every 90 days" --parent 43

Creates:

Project: E-commerce platform (ID: 42)
  └── Authentication uses JWT tokens (ID: 43)
       └── JWT secret rotation every 90 days (ID: 44)

Layer 3: Knowledge Graph

TF-IDF entity extraction + Leiden clustering automatically discovers relationships.

# Extract entities using TF-IDF
entities = extract_entities_tfidf(all_memories)

# Build graph
graph = igraph.Graph()
# Add edges based on entity co-occurrence
# Cluster using Leiden algorithm
communities = graph.community_leiden()

Result: Memories automatically group into topics (authentication, database, UI, etc.) without manual tagging.

Layer 4: Pattern Learning

Bayesian confidence scoring learns your preferences over time.

# MACLA: Beta-Binomial Bayesian posterior
def update_confidence(pattern, feedback):
    alpha_new = pattern.alpha + (1 if feedback == 'positive' else 0)
    beta_new = pattern.beta + (1 if feedback == 'negative' else 0)
    confidence = alpha_new / (alpha_new + beta_new)
    return confidence

Learns:

"I prefer TypeScript strict mode" (confidence: 0.95)
"I use Tailwind for styling" (confidence: 0.87)
"API responses always include status codes" (confidence: 0.91)

Layer 6: MCP Integration

Model Context Protocol (Anthropic, 2024) provides native tool integration.

{
  "mcpServers": {
    "memory": {
      "command": "python3",
      "args": ["/Users/you/.claude-memory/mcp_server.py"]
    }
  }
}

Tools available to Claude:

remember - Save new memory
recall - Search memories
list_recent - Show recent memories
get_memory - Retrieve specific memory
update_memory - Modify existing memory
delete_memory - Remove memory

Claude calls these automatically when needed. No manual intervention.

Layer 5: Universal Skills

Works with tools that don't support MCP via slash commands:

/superlocalmemoryv2:remember "content" --tags tag1,tag2
/superlocalmemoryv2:recall "search query"
/superlocalmemoryv2:list-recent 20

Compatible with:

Claude Code
Continue.dev
Cody
Cursor (via skills)
Windsurf (via skills)

Layer 7: CLI Access

Terminal and script integration:

# Save memory
slm remember "Next.js 14 uses App Router by default" --tags nextjs,framework

# Search memory
slm recall "nextjs routing"

# List recent
slm list-recent 50

# Build knowledge graph
slm build-graph

# Switch profiles
slm switch-profile personal

Layer 9: Web Dashboard

Real-time visualization of memory operations:

Features:

Live event stream (SSE-powered)
Timeline view of all memories
Knowledge graph explorer (force-directed layout)
Pattern learning dashboard
Multi-profile switcher
Search with filters

python3 ~/.claude-memory/ui_server.py
# Open http://localhost:8765

Installation: One Command

npm install -g superlocalmemory

That's it. No configuration needed.

The installer:

Creates ~/.claude-memory/ directory
Installs Python components
Auto-detects AI tools on your system
Configures MCP for Claude Desktop, Cursor, Windsurf, etc.
Installs CLI commands
Sets up shell completions (bash/zsh)

Manual Installation

git clone https://github.com/varun369/SuperLocalMemoryV2.git
cd SuperLocalMemoryV2
./install.sh

Real-World Usage

Use Case 1: Cross-Tool Context

Save research in one tool, recall in another:

# In Perplexity: research Next.js 15 features
# (manually save findings)
slm remember "Next.js 15 introduces Turbopack as stable" --tags nextjs,research

# Later, in Cursor
You: "What's new in Next.js 15?"
Claude (via MCP recall): "Next.js 15 introduces Turbopack as stable"

Use Case 2: Project Profiles

Switch between projects with full context:

# Work project
slm switch-profile accenture-client-portal
slm remember "API uses OAuth 2.0 with PKCE flow"

# Personal project
slm switch-profile personal-blog
slm remember "Uses Astro with Tailwind"

# Each profile has separate memory

Use Case 3: Pattern Learning

SuperLocalMemory learns your style automatically:

After several sessions where you:

Always request TypeScript over JavaScript
Prefer functional components in React
Use Tailwind for styling
Write tests with Vitest

Result: Claude starts suggesting these patterns without being asked, because pattern learning surfaces high-confidence preferences.

Technical Deep Dive: How Recall Works

When Claude calls recall("authentication"):

FTS5 Full-Text Search (Layer 1)

   SELECT * FROM memories_fts WHERE memories_fts MATCH 'authentication'

TF-IDF Vector Similarity (Layer 1)

   query_vector = compute_tfidf(query)
   cosine_scores = cosine_similarity(query_vector, memory_vectors)

Graph Traversal (Layer 3)

   # Find related memories via graph edges
   related_ids = graph.neighbors(top_match_id)

Hierarchical Expansion (Layer 2)

   # Include parent/child context
   breadcrumbs = get_breadcrumbs(memory_id)

Hybrid Ranking (Layer 8)

   # Combine all signals
   final_score = (
       0.4 * fts5_score +
       0.3 * tfidf_score +
       0.2 * graph_score +
       0.1 * recency_score
   )

Return Top K (default: 10 results)

Performance: <50ms for most queries, even with 10K+ memories.

Research Foundations

SuperLocalMemory is built on published research, adapted for local-first operation:

Layer	Research	Citation
A2A (Layer 10)	A2A Protocol	Google/Linux Foundation, 2025
Hierarchical Index (Layer 2)	PageIndex	VectifyAI, 2025
Knowledge Graph (Layer 3)	GraphRAG	Microsoft (arXiv:2404.16130), 2024
Pattern Learning (Layer 4)	MACLA	arXiv:2512.18950, 2025
Hybrid Search (Layer 8)	A-RAG	arXiv:2602.03442, 2026

Key adaptation: All research papers assume cloud APIs (OpenAI embeddings, hosted graphs). SuperLocalMemory implements everything locally with zero API calls.

Roadmap: What's Next

v2.5 (March 2026) - "Your AI Memory Has a Heartbeat"

✅ Real-time event stream (SSE)
✅ Concurrent access (WAL mode, write queue)
✅ Agent tracking (which tool wrote what)
✅ Trust scoring (Bayesian confidence)
✅ Memory provenance

v2.6 (May 2026) - "Your AI Agents Share One Brain"

A2A Protocol server
Agent Card for discovery
Multi-agent collaboration
Trust enforcement

v2.7 (Jul-Aug 2026) - "Your AI Identity, Portable"

Identity export/import
EU AI Act compliance (Aug 2026)
Portable agent profiles

v3.0 (Oct 2026) - "Enterprise AI Memory Platform"

Multi-tenant support
Admin control panel
Shared project memory
Team collaboration

Comparison: SuperLocalMemory vs Alternatives

Feature	SuperLocalMemory	Mem0	Zep	Letta	MCP Memory (ref)
Privacy	100% local	Cloud	Cloud	Cloud	Local
Cost	Free	$50+/mo	$50+/mo	$40+/mo	Free
Knowledge Graph	✅ Leiden clustering	✅	✅	❌	❌
Pattern Learning	✅ Bayesian	❌	❌	❌	❌
Multi-tool	16+ tools	Limited	Limited	Limited	MCP only
CLI Access	✅	❌	❌	❌	❌
Web Dashboard	✅	✅	✅	✅	❌
A2A Protocol	v2.6 planned	❌	❌	❌	❌
Production-Grade	✅	✅	✅	✅	❌ (reference)

Why Local-First Matters

Privacy: Your code, your bugs, your strategies never leave your machine.

Ownership: Stop paying → you still have ALL your data.

Speed: No network latency. 50ms average query time.

Reliability: Works offline. No API quotas. No rate limits.

Cost: $0 forever. No credit card. No trials. No upsells.

Getting Started

# 1. Install
npm install -g superlocalmemory

# 2. Save your first memory
slm remember "I prefer TypeScript strict mode" --tags preferences,typescript

# 3. Open Claude Desktop
# Memory is automatically available via MCP

# 4. Launch dashboard (optional)
python3 ~/.claude-memory/ui_server.py