SuperLocalMemory – Local-First AI Agent Memory

TL;DR

TL;DR: SuperLocalMemory is an AGPL local-first memory control plane for AI agents that runs entirely on your infrastructure, with MCP and CLI surfaces, temporal retrieval, and GDPR/EU AI Act governance controls built in.

Source and Accuracy Notes

This section is MANDATORY. All links verified from actual source.

• Project page: superlocalmemory.com
• Source repository: github.com/varun369/SuperLocalMemoryV2
• License: AGPL v3 (verified via LICENSE file in repo root)
• PyPI package: pypi.org/project/superlocalmemory
• npm package: npmjs.com/package/superlocalmemory
• HN launch thread: news.ycombinator.com/item?id=46926968
• Source last checked: 2026-07-29 (README commit main)

What Is SuperLocalMemory?

SuperLocalMemory is an enterprise-grade, local-first memory control plane for AI agents. It gives a long-lived agent a persistent, auditable brain that runs entirely on your own infrastructure — no external API calls, no data leaving your environment by default.

The core idea: most agent memory systems treat memory as a soft concern, storing what an agent learned in a vector DB. SuperLocalMemory goes further — it records when something was learned, where it came from, and can decay or self-archive neglected facts over time. Every fact carries ingestion timing and provenance; recall runs a dedicated temporal channel alongside semantic, lexical, and associative retrieval.

It ships as a zero-config CLI proxy, native MCP server, or IDE plugin for Claude and Codex. The default local runtime does not require Docker or a separately operated graph database.

Setup Workflow

Step 1: Install

SuperLocalMemory is available on both pip and npm:

pip install superlocalmemory
# or
npm install -g superlocalmemory

Step 2: Verify the install

slm --help

The CLI exposes three surfaces: a proxy wrap (slm wrap claude), an MCP server (slm_compress in your MCP config), and a standalone skill. The README confirms the default local runtime requires no Docker, no separately operated graph database, and no API key.

Step 3: Configure for your framework

SuperLocalMemory v3.8.8 includes drop-in, engine-backed memory adapters for nine agent frameworks. For a Python-based agent, the README shows:

from superlocalmemory import SuperLocalMemory

slm = SuperLocalMemory(mode="local")

For Claude, wrap the CLI:

slm wrap claude

For MCP-compatible hosts (Cursor, VS Code Copilot, etc.), add to your MCP config:

{
  "mcpServers": {
    "slm_compress": {
      "command": "slm",
      "args": ["mcp", "serve"]
    }
  }
}

Step 4: First memory query

After running an agent session with SLM active, query its memory:

slm recall "what did we decide about the API design"

Deeper Analysis

Temporal depth

Most RAG systems retrieve facts by semantic similarity only. SuperLocalMemory’s V3 release introduced a dedicated temporal retrieval channel — every ingested fact carries an ingestion timestamp and provenance. Recall scores facts by when they were learned alongside relevance, so an agent can distinguish “what the project used to do” from “what it does now.”

Team and enterprise governance (v3.8.0+)

The 3.8.0 release added workspace isolation, role-based access, a hash-chained audit trail, and GDPR/EU AI Act compliance controls. This is relevant for organizations deploying agents in regulated environments — the README explicitly calls out EU data-residency obligations.

Bounded loops

A persistent pain point with autonomous agents is an agent declaring a task complete when it is not. SLM v3.8.0 introduced gate-verified loops where an independent check — not the agent’s own claim — decides when a task is done.

Framework adapters

The README documents drop-in adapters for nine agent frameworks. The exact framework list and integration method are in the framework adapters section of the README.

Practical Evaluation Checklist

• Local runtime requires no Docker, no separate graph DB, no API key
• Three surfaces: CLI proxy, MCP server, Claude/Codex plugin
• Temporal retrieval with dedicated time-aware ranking channel
• Team workspaces with role-based isolation
• Hash-chained audit trail
• GDPR data access, erasure, and portability rights built in
• EU AI Act self-assessment documentation included
• Bounded loops: gate-verified task completion
• Framework adapters for nine agent frameworks (v3.8.0+)
• Open source: AGPL v3

Security Notes

• Default mode is fully offline — no external API calls required
• Data stays on your infrastructure unless you explicitly opt into cloud backup
• GDPR access, erasure, and portability rights are first-class features
• EU AI Act self-assessment documentation ships with the product
• Audit trail is hash-chained for tamper-evidence

License note: SuperLocalMemory is AGPL v3. This means modifications to the core software must be released under the same license. If you deploy it as a hosted service, you must make your source available. Evaluate AGPL compatibility with your organization’s licensing requirements before deployment.

FAQ

Q: Does it work with agents other than Claude and Codex? A: Yes. The MCP server surface works with any MCP-compatible agent runtime. Framework adapters cover nine frameworks listed in the README, and the CLI proxy can wrap most terminal-based agent interactions.

Q: How is this different from Mem0 or Letta? A: The README includes an explicit comparison table. SuperLocalMemory’s boundary is a local-first operating control plane — not just an SDK or managed context API. It combines temporal depth, graph-aware retrieval, cache/compression controls, and governance in one install. Mem0 is positioned as a memory SDK and managed platform. Letta focuses on stateful agent runtimes with memory blocks.

Q: Does it require a separate vector database? A: No. The default local runtime does not require Docker, a separately operated graph database, or an API key. It runs as a standalone Python process with the vector and graph capabilities embedded.

Conclusion

SuperLocalMemory fills the gap between fragile in-context memory and fully managed SaaS memory services. It runs on your infrastructure, tracks when facts were learned (not just what), and ships with the governance controls that enterprise AI deployments require. The AGPL v3 license keeps it open while requiring network-access deployments to share modifications.

If you run long-lived agents in contexts where data residency matters, or if you need agents that can reason about the history of their own knowledge, it is worth a look.

Project page: superlocalmemory.com
Source: github.com/varun369/SuperLocalMemoryV2