MCP — Model Context Protocol

One protocol.
Profiled memory tools
remembers.

SuperLocalMemory exposes profile-selected MCP tools for memory, lifecycle, diagnostics, and optional capabilities. Tool availability and client compatibility must be checked against the installed release.

Install & Connect Read the Paper
// MCP connection topology
Claude / Cursor / Windsurf
MCP client · JSON-RPC 2.0
tools/call
SLM MCP Server
profile-selected tools · stdio / HTTP
hybrid retrieval
SQLite
normal-path source of truth
Optional projectors
experimental · configured only
Named
Tool profiles
Explicit
Setup and client consent
Exact
Explicit-key MCP cache
Mode A
Local core provider boundary
The MCP Surface

Example tools.
Profiles define the surface.

The cards below illustrate common workflows. The installed tool list depends on the selected MCP profile, optional features, and release. Query the server instead of relying on a fixed marketing count.

remember
async (content, tags?, project?, importance?, session_id?, agent_id?, scope?, shared_with?, idempotency_key?) → receipt
Submit content to canonical durable ingestion. The receipt reports fact IDs and materialization state; daemon-backed receipts can also include an operation ID and pending status.
contentstring*The memory text to store
tags / projectstringOptional classification fields
scope / shared_withstringOptional visibility controls
idempotency_keystringOptional stable retry identity
recall
async (query, limit?, agent_id?, session_id?, fast?, include_global?, include_shared?) → result
Retrieve memories from five candidate-producing channels, fusion, optional reranking, and graph or Fisher-informed score enhancement. Dense candidates use cosine similarity. Results expose Score Contract v2 fields rather than an answer probability.
querystring*Natural language query
limitnumberMax results (default: 5)
scope flagsbooleanExplicitly include global or shared scope; defaults come from configuration
search
async (query, limit?, profile_id?) → result
Run FTS5 full-text search with BM25 ranking for the selected profile. This tool is lexical search; use recall for the multi-channel retrieval pipeline.
querystring*Search terms
limitnumberMaximum results (default: 10)
profile_idstringOptional explicit profile; empty uses the active profile
slm_compress
async (content, mode?, reversible?, ttl_seconds?) → result
Apply content-aware extractive compression within a token budget. Results depend on the input; safety-preserving JSON and code paths can return the original content with no reduction.
contentstring*Text or tool output to compress (maximum 1 MB)
modestringnormalize, auto, or aggressive
reversiblebooleanRetain the original in CCR when the result is lossy
slm_cache_set / get
async (key, value?, ttl?) → any
Agent-scoped, TTL-bounded exact key/value cache. Set stores a string result explicitly routed through SLM; get returns that value only when the same caller key exists and has not expired. It is not the separate experimental semantic-cache path.
keystring*Stable caller-supplied key
valuestringResult to cache (set only; maximum 1 MB)
ttl_secondsnumberTime-to-live in seconds (default: 86400)
slm_retrieve
async (ccr_id) → result
Recover original text retained by a reversible lossy slm_compress call. The CCR identifier is a retrieval capability and expires according to its configured lifetime; it is not a memory fact ID.
ccr_idstring*UUID4 returned by lossy compression when reversible storage succeeds
get_status
async () → SLMStatus
Returns the active mode, provider, profile, data paths, database size, fact count, entity count, and graph-edge count. Cache statistics and daemon uptime belong to separate diagnostic surfaces.
—No parameters required
Quick Start

Install, configure,
then verify.

Use an isolated installer, configure the client explicitly, and prove a real remember() and recall round trip.

1

Install SLM

Use pipx or uv with Python 3.11–3.14. Mode A does not require a model-provider key for its core path; optional modes and features have separate requirements.

terminal 
pipx install superlocalmemory
slm setup
2

Add to claude_desktop_config.json

Point a documented MCP client at the SLM server, then run the end-to-end memory contract. Protocol support alone does not prove client compatibility.

~/Library/Application Support/Claude/claude_desktop_config.json 
{
  "mcpServers": {
    "superlocalmemory": {
      "command": "slm",
      "args": ["mcp"]
    }
  }
}
3

Verify the connection

Restart your MCP client. Ask it to call get_status — you should see the active profile, mode, provider boundary, data paths, and current store counts.

example agent message 
// In Claude Desktop or Cursor, tell the agent:
"Use the superlocalmemory MCP to call get_status"

// Expected response:
{
  "success": true,
  "mode": "A",
  "provider": "none",
  "profile": "default",
  "fact_count": 0
}
Advanced

HTTP daemon & stdio transport

Use slm start for the local HTTP daemon or slm mcp for a client-owned stdio process. Verify the endpoint and authentication boundary in the installed release.

Local HTTP daemon 
# Start the local HTTP daemon
slm start

# Point a supported HTTP MCP client at:
"url": "http://127.0.0.1:8765/mcp/"
stdio fallback 
# A client-owned stdio process
slm mcp

# Inspect the release-current mode and health
slm status --json
slm doctor
Compatibility

Verify each
documented MCP client.

Transport and protocol support are prerequisites, not proof. Publish a client only after install, session, remember, recall, update, forget, restart, and uninstall checks pass.

Claude Desktop
stdio · release verification required
Claude Code
stdio · full session memory
Cursor
stdio · composerAgent
Windsurf
stdio · Cascade MCP
Cline
stdio · full spec
Zed Editor
stdio · context extension
Continue
stdio · VS Code + JetBrains
Custom agents
JSON-RPC 2.0 · SSE
Best Practice

A minimal system prompt
for explicit memory use.

Add these instructions when you want the agent to call the configured SLM tools. Tool availability, policy authorization, and retrieval quality still depend on the installed profile and release.

system prompt addition 
# Add to your system prompt:

Before responding to questions, check SuperLocalMemory
for relevant context using the recall tool.

After making decisions, fixing bugs, or learning
preferences, store them using the remember tool.

On session start, call get_status to confirm
SLM is healthy.
FAQ

Common questions

Mode A keeps the core memory-content path in the configured local data root. Optional providers, connectors, backups, proxies, and model downloads can use the network and must be configured and assessed separately.
Only when the client actually exposes the configured SLM tools to that subagent. Verify tool visibility and agent identity for each client and subagent type; a parent client configuration is not by itself proof of inheritance or shared scope.
recall uses five candidate producers, fusion, optional reranking, and post-fusion graph or Fisher-informed enhancement. Dense candidates use cosine similarity. search is profile-scoped FTS5 lexical search with BM25 ranking. Inspect recall's trace and Score Contract v2 fields instead of treating rank as answer probability.
Use explicit profiles, data roots, and process configuration when you need isolation. The remember tool accepts project metadata, but the core recall tool does not expose a project-filter parameter, so project metadata alone is not an instance boundary.
Capacity and latency depend on corpus shape, indexes, configuration, and hardware. Use the release benchmark harness on a representative corpus and configure bounded storage for an explicit operational limit.
Compatibility is release- and client-specific. Verify initialization, tool discovery, tool calls, error envelopes, and shutdown against the installed package and the exact client/version you plan to support; this page does not claim universal revision parity.
Ready?

Your agents,
finally remembering.

Install in an isolated environment, approve setup, then verify the memory round trip in your actual client.

Get Started Read the Paper