Power your agent
पब्लिशर की अपनी कमांड। PlugMCP एंडपॉइंट नहीं।
Host a copy with our keys and logs.
npx -y [email protected]Claude Code में लोकल कमांड के लिए इंस्टॉल लिंक नहीं है। नीचे दी गई कमांड कॉपी करें और टर्मिनल में चलाएँ।
OPENAI_API_KEY=<secret> NAN_FORGET_EMBEDDING_PROVIDER=<value> NAN_FORGET_USER_ID=<value> NAN_FORGET_PROJECT_ROOT=<value> claude mcp add io.github.nanmesh-nan-forget -- npx -y nan-forget@0.6.8टर्मिनल में चलाएँ।
{ "mcpServers": { "io.github.nanmesh-nan-forget": { "command": "npx", "args": [ "-y", "[email protected]" ], "env": { "OPENAI_API_KEY": "<secret>", "NAN_FORGET_EMBEDDING_PROVIDER": "<value>", "NAN_FORGET_USER_ID": "<value>", "NAN_FORGET_PROJECT_ROOT": "<value>" } } }}claude_desktop_config.json
रिमोट URL या आपकी मशीन पर कमांड? दोनों इंस्टॉल में क्या अंतर है
PlugMCP पर चलाएँ
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
लॉन्चपब्लिशर से
Long-term memory for AI coding tools.
Your AI forgets everything when the session ends. NaN Forget fixes that.
npx nan-forget setup
That's it. The wizard installs Ollama, embeddings, Claude hooks, MCP config, and a project for Codex-style agents. Restart Claude Code or reopen Codex. Your AI now remembers.
AI that remembers. Local-first cross-session, cross-project long-term memory for coding tools.
AGENTS.mdNo API keys needed. No Docker needed. Runs locally. Free forever.
flowchart LR
A["You talk to your AI tool"] --> B["It learns things"]
B --> C["nan-forget saves to SQLite"]
C --> D["Session ends"]
D --> E["New session starts"]
E --> F["nan-forget loads context"]
F --> G["Your AI remembers"]
~/.nan-forget/memories.db. Aging memories get automatically compacted into long-term entries.You never call save or search manually. Here's what happens behind the scenes:
Four layers of protection ensure nothing is lost:
Codex and similar agents work well with nan-forget, but they usually need instruction files or shell/API fallbacks instead of Claude's hook model:
npx nan-forget setupAGENTS.md in your repo. It tells Codex-style agents to sync, search, save, and checkpoint automatically.localhost:3456 or local commands like nan-forget sync, nan-forget search, nan-forget add, and nan-forget checkpoint.The REST API and CLI now mirror the important memory workflows closely enough that memories saved by Claude are searchable from Codex and vice versa.
# Start the REST API
nan-forget api
# The system prompt tells your agent exactly what endpoints to call
nan-forget prompt
Type these in Claude Code:
Claude uses MCP. Codex can use AGENTS.md plus CLI/REST fallback:
# Start the API
nan-forget api
# Get the system prompt for your agent
nan-forget prompt
Codex, Cursor, and Claude all share the same memory database.
curl http://localhost:3456/memories/search?q=auth
curl -X POST http://localhost:3456/memories/sync -d '{"project":"my-app"}'
curl -X POST http://localhost:3456/memories/checkpoint \
-H 'content-type: application/json' \
-d '{"task_summary":"Fixed auth regression","problem":"Expired tokens were not refreshed","solution":"Added refresh handling in middleware","files":["src/auth.ts"],"concepts":["auth","jwt"],"project":"my-app"}'
nan-forget add "We use FastAPI, not Django. Railway deploys faster."
nan-forget add --type decision "Auth is Clerk, not custom JWT"
nan-forget search "what auth system"
nan-forget stats
Everything below is for developers who want to understand how nan-forget works under the hood.
LLMs have no memory between sessions. Every conversation starts from zero. You re-explain your stack, Claude contradicts decisions from last month, and context disappears when the session ends.
Existing solutions (Mem0) target app developers embedding memory into products. We target you — the developer using AI tools daily who wants AI that just remembers.
flowchart TB
subgraph Short["Short-Term Memory"]
MD[".md files<br/>Current session context<br/>Disposable scratch paper"]
end
subgraph Long["Long-Term Memory"]
DB["SQLite + sqlite-vec<br/>~/.nan-forget/memories.db<br/>Semantic search + decay"]
end
subgraph Auto["Automatic Processes"]
Hook["Hooks (3)<br/>PostToolUse: .md → DB<br/>UserPromptSubmit: auto-recall<br/>SessionEnd: transcript sweep"]
Consolidate["Consolidation Engine<br/>Clusters + summarizes aging memories"]
GC["Garbage Collection<br/>Decay, dedup, expiry"]
end
MD -->|"hook intercepts"| Hook
Hook -->|"nan-forget add"| DB
DB --> Consolidate
Consolidate --> DB
DB --> GC
Short-term memory = Claude's built-in .md files. Disposable. Current session only.
Long-term memory = SQLite database with sqlite-vec vector search. Single file. Permanent. Searchable across all sessions, all projects, all LLM tools.
Three hooks handle memory automatically:
.md file writes and saves them to the DB.nan-forget recall on every user message, auto-searching memory for relevant context.Memory search follows the same path as human recall:
flowchart LR
Q["Query"] --> S1["Stage 1: Recognition<br/>Fast vector match<br/>Returns summaries only"]
S1 --> S2["Stage 2: Recall<br/>Full content fetch<br/>Cross-project expansion"]
S2 --> S3["Stage 3: Association<br/>Spreading activation<br/>Related memories surface"]
S3 --> R["Results ranked by<br/>similarity x decay x frequency x confidence"]
Scoring formula:
final_score = vector_similarity * decay_weight * frequency_boost * confidence_boost
decay_weight = (0.5 ^ (days / 30)) ^ (1 - confidence)
frequency_boost = log2(access_count + 1) / 10 + 1
confidence_boost = 0.5 + 0.5 * confidence
High-confidence memories (debate-validated, human-approved) decay much slower and rank higher. A core memory at 0.85 confidence decays at ~15% of normal rate — effectively permanent unless superseded. Cross-project search means auth decisions from Project A surface when you work on Project B.
Aging memories don't just get deleted — they get compacted into long-term entries:
flowchart TB
A["10+ aging memories<br/>about the same topic"] --> B["Cluster by project + type<br/>+ vector similarity > 0.8"]
B --> C{"OpenAI key<br/>available?"}
C -->|"Yes"| D["LLM summarizes cluster<br/>into 1-2 sentences"]
C -->|"No"| E["Deterministic merge<br/>concatenate + deduplicate"]
D --> F["Save consolidated entry<br/>with fresh vector embedding"]
E --> F
F --> G["Archive originals<br/>with backlink"]
Triggers automatically after every 10 saves or 24 hours. No user action needed.
memory_save accepts structured fields for richer vector representation:
All fields are embedded together into a single vector. Searches for "JWT auth bug" find memories tagged with those concepts even if the content text doesn't match literally.
Not all memories are equal. Debate-validated and human-approved memories are core — they decay slower, rank higher in search, and survive garbage collection longer.
Core memories are designed for the upcoming nan-debate system — multi-AI debate results validated by human approval get persisted as high-trust knowledge that almost never fades.
After completing a task, call memory_checkpoint with task_summary, problem, solution, files, concepts, and project. Saves the full problem→solution context to long-term memory. Every completed task = one checkpoint.
memory_compress scans .claude/projects/*/memory/ for .md files already persisted to the DB. Persisted files are replaced with minimal stubs. Reduces context window bloat.
Shares the same SQLite database as the MCP server — memories saved by Claude are searchable from Codex and vice versa.
POST /memories — Save a memory (supports problem/solution/files/concepts)
POST /memories/checkpoint — Save completed-task context
POST /memories/sync — Lightweight session handshake
GET /memories/search?q=... — Semantic search
GET /memories/:id — Get by ID
PATCH /memories/:id — Update
DELETE /memories/:id — Archive
POST /memories/consolidate — Compact aging memories
POST /memories/clean — Garbage collection
GET /memories/stats — Memory health
GET /memories/instructions — System prompt for LLMs
Get the system prompt for any LLM:
nan-forget prompt
# or
curl http://localhost:3456/memories/instructions
Auto-detection: Ollama running? Use it. Not running? Check for OPENAI_API_KEY. No config needed.
All data lives in a single SQLite file at ~/.nan-forget/memories.db. No Docker, no services, no data loss on updates.
user_id, status, project, typenan-forget export dumps all memories as JSON.flowchart TB
A["New memory saved"] --> B["Active in SQLite<br/>Searchable, scored"]
B --> C{"Accessed<br/>recently?"}
C -->|"Yes"| D["Score stays high<br/>frequency_boost increases"]
C -->|"No"| E["Decay weight drops<br/>0.5^(days/30)"]
E --> F{"Decay < 0.3?"}
F -->|"Yes"| G["Consolidation candidate<br/>Clustered + summarized"]
F -->|"No"| B
G --> H["New consolidated entry<br/>Originals archived"]
D --> B
E --> I{"Decay < 0.1?"}
I -->|"Yes"| J["Archived by GC"]
I -->|"No"| F
All cleanup is deterministic. No API calls. No LLM inference.
expires_at dateCore memories (confidence ≥ 0.85) survive GC far longer than regular ones because their decay formula dampens the time factor: decay^(1 - confidence). A 0.85-confidence memory at 200 days still has a decay weight above 0.1.
NaN Forget is built around three principles: lightweight, automatic, and local.
No Docker. No cloud services. No background processes eating RAM. The entire storage layer is a single SQLite file (~3 MB). Embeddings run through Ollama, which you likely already have. Memory operations (save, search, dedup, GC) use zero LLM calls — all deterministic.
Four hooks capture context at every stage of a session — you never call save manually:
.md file writes and persists themAging memories consolidate automatically. Duplicates merge. Unused memories decay on a 30-day half-life. No maintenance required.
Your data stays on your machine in ~/.nan-forget/memories.db. No accounts, no API keys required (Ollama is free and local), no telemetry. Backup is copying one file. Works across Claude Code (MCP), Codex/Cursor (REST API), and the terminal (CLI) — same database, same memories.
Most AI memory solutions (Mem0, claude-mem) are designed for app developers embedding memory into products, or require Docker/cloud services to run. NaN Forget is designed for you — the developer using AI tools daily who wants context that persists across sessions without managing infrastructure.
Key design differences:
problem, solution, concepts, and files fields — searches find related context even when keywords don't matchnpx nan-forget setup), no Docker, no containers, no services to managesrc/
sqlite.ts SQLite + sqlite-vec storage layer (schema, CRUD, vector search)
embeddings.ts OpenAI / Ollama abstraction
writer.ts Memory writer with dedup (>0.92 = merge)
retriever.ts Three-stage retrieval pipeline
consolidator.ts LLM summarization + deterministic fallback
cleaner.ts GC: decay, expiry, dedup, MEMORY.md sync
services.ts Service management (Ollama, REST API)
memory-md.ts MEMORY.md manager
types.ts Shared types (Memory, MemoryType, etc.)
mcp/server.ts MCP server, 13 tools
api/server.ts REST API server
cli/index.ts CLI commands + hook helpers
setup/index.ts Setup wizard (Ollama, hooks, MCP config)
.claude/
commands/nan-forget.md Slash command for manual control
hooks/memory-sync.js PostToolUse hook (auto-saves .md → SQLite)
hooks/session-end.js SessionEnd hook (transcript sweep for unsaved memories)
settings.json Hook config (PostToolUse + SessionEnd + UserPromptSubmit)
MIT License.
AI that remembers. Local-first cross-session, cross-project long-term memory for coding tools.
{ "mcpServers": { "io.github.nanmesh-nan-forget": { "command": "npx", "args": [ "-y", "[email protected]" ], "env": { "OPENAI_API_KEY": "<secret>", "NAN_FORGET_EMBEDDING_PROVIDER": "<value>", "NAN_FORGET_USER_ID": "<value>", "NAN_FORGET_PROJECT_ROOT": "<value>" } } }}टूल
अभी टूल सूची नहीं है। रिमोट सर्वर को पहले हेल्थ चेक के बाद सूची मिलती है।
FAQ
इस पेज पर Cursor, Claude Desktop, Claude Code या VS Code के लिए stdio कॉन्फ़िग कॉपी करें। यह पब्लिशर का इंस्टॉल इस्तेमाल करता है, PlugMCP प्रॉक्सी नहीं।
पब्लिशर ने ये एनवायरनमेंट वेरिएबल बताए हैं: OPENAI_API_KEY, NAN_FORGET_EMBEDDING_PROVIDER, NAN_FORGET_USER_ID, NAN_FORGET_PROJECT_ROOT।
Nan Forget stdio पर लोकल चलता है।
पिछली जाँच 2026-11-09 को हुई। AI that remembers. Local-first cross-session, cross-project long-term memory for coding tools.