SMRITI Memory

SMRITI Memcore

Enterprise-grade, privacy-first Long-Term Memory (LTM) engine for LLM agents, multi-agent frameworks, and MCP clients.

www.smriti-memcore.com

[PyPI] [Python 3.9+] [License: MIT] [Website] [SMRITI Memory MCP server]

[SMRITI Memory Browser & Graph Explorer Demo]

Interactive Semantic Palace Graph Browser (smriti ui) — Category Room hub clustering, neural synaptic particle flow, and real-time dual inspector. Watch Full-Res Video

What is SMRITI?

SMRITI is a high-performance, neuro-inspired long-term memory layer designed to give AI agents persistent, adaptive recall without blocking their real-time execution loop.

Inspired by human Dual-Process cognitive theory, SMRITI splits memory operations into:

1. System 1 (Immediate Heuristics): Decoupled, millisecond-level ingestion of raw interactions into an append-only Episode Buffer.
2. System 2 (Async Consolidation): Background LLM-driven consolidation that extracts knowledge graphs, resolves contradictions, identifies skills, and decays weak memories.

SMRITI vs. Naive RAG & Vector Databases

Key Capabilities

• Dual-Process Performance: Zero-blocking real-time loops. Write immediately, analyze when idle.
• Persona Palaces & On-Demand Hub: Download pre-curated cognitive memory palaces for historical figures (e.g., Albert Einstein, Isaac Newton) and converse with them with authentic mental models.
• Privacy-First (Private Rooms): Create local semantic rooms whose memories are automatically excluded from shared/team-wide sync.
• Model Context Protocol (MCP): Native MCP server integration with Claude Code, Claude Desktop, Gemini Antigravity, and Codex.
• AMP v1.0 Spec Compliant: Drop-in compatibility with any agent framework conforming to the Agent Memory Protocol.
• Visual Graph Explorer: Clean D3.js-based visualization interface with Prometheus metrics monitoring.
• Obsidian Vault Integration: Automatically syncs your agent's memory graph into an Obsidian vault for human curation.
• Framework Agnostic: Integrates natively with LangChain, LlamaIndex, CrewAI, and AutoGen.

Core Architecture

                           ┌─────────────────────────────────┐                           │    Asynchronous Consolidation   │                           │      (8 Background Processes)   │                           │  • Chunking      • Cross-Ref.   │                           │  • Conflict Res. • Skill Ext.   │                           │  • Forgetting    • Spaced Rep.  │                           │  • Reflection    • Defragment.  │                           └────────────────┬────────────────┘                                            │ background  ┌──────────┐   ┌──────────┐   ┌───────────▼─────────┐   ┌──────────┐  │  Input   │──▶│ Attention │──▶│   Episode Buffer    │──▶│ Semantic │  │  Text    │   │   Gate    │   │  (append-only log)  │   │  Palace  │  │  └───────┘   │ (salience │   └─────────────────────┘   │  Graph   │  │              │  filter)  │                              │ G=(V,E)  │  └──────────┘   └──────────┘                              └────┬─────┘                                                                │  ┌──────────┐   ┌──────────┐   ┌───────────────────┐           │  │  Query   │──▶│ Retrieval│──▶│  Working Memory   │◀──────────┘  │          │   │  Engine  │   │   (7 ± 2 slots)   │  └──────────┘   │ Q(v) =   │   └───────────────────┘                 │ β₁cos +  │                 │ β₂decay+ │   ┌───────────────────┐                 │ β₃freq + │──▶│    Meta-Memory    │                 │ β₄sal    │   │ (confidence map)  │                 └──────────┘   └───────────────────┘

Quick Start

1. Install SMRITI

Install the core memory engine and CLI:

pip install smriti-memcore

(Optional: Ensure Ollama is running locally for 100% private, free LLM inference: ollama run mistral)

2. Instructions for Professors & Course Creators: Package Your Curriculum

Turn your raw lecture folder into a self-contained, offline-first Cognitive Palace Bundle (.smritibundle) that acts as a 24/7 Socratic Teaching Assistant for your students.

# Package a folder of slides, transcripts, readings, or notebooks into an offline bundle:smriti pack ./my-course-folder -o cs101.smritibundle
# Or package directly from a declarative YAML/JSON persona spec:smriti pack ./course-spec.yaml -o cs101.smritibundle --install

• Supported Formats: PDF slides, WebVTT/SRT video lecture transcripts, Markdown, plain text, and Jupyter notebooks (.ipynb).
• Zero Cloud Costs: All vector embeddings are calculated locally ($0 OpenAI/HuggingFace API bills).
• Lightweight Distribution: Generates a self-contained archive (typically 5–15 MB) containing the vector index, full-text search, and semantic graph. Upload it directly to Canvas, Blackboard, Piazza, Google Drive, or email it to students.

3. Instructions for Students: 24/7 Socratic Office Hours

Students download the professor's .smritibundle and converse with an interactive course mentor directly in their terminal—100% offline, private, and subscription-free.

# Step 1: Import the course bundle provided by your professorsmriti pull ./cs101.smritibundle
# Step 2: Start your 24/7 Socratic Office Hourssmriti chat cs101
# (Optional) Use a specific local Ollama model (e.g. Mistral, Qwen, Llama)smriti chat cs101 --model mistralsmriti chat cs101 --model qwen3.5

• Pinpoint Attribution: Asks about any concept and surfaces exact slide page numbers and video lecture transcript quotes.
• Socratic Pedagogy: Rather than simply giving away homework answers, the course persona guides students step-by-step from first principles using course analogies.
• 100% Local & Private: All conversations stay on the student's laptop—zero student data is sent to external servers.

Pre-Curated Mentors in Official Registry

You can also explore out-of-the-box mentors right away:

# List all available mentors and locally installed bundlessmriti list
# Socratic Distributed Systems Professor (Raft, Paxos, CAP theorem)smriti chat prof-systems
# 100% Private, Local CBT & Mindfulness Companionsmriti chat mindful-counsellor
# Historical Thinkerssmriti chat einsteinsmriti chat newtonsmriti chat marcus-aurelius

4. Smriti DevBrain: Universal Developer Memory (Cursor, Claude, Windsurf, Gemini, Zed)

SMRITI solves cross-agent amnesia by acting as a shared, local cognitive brain across all your AI coding tools. A bug solved in Claude Code or Gemini is immediately remembered by Cursor.

Step 1: Auto-Configure All Installed IDEs & Agents

Run one command to scan and configure Cursor, Claude Code, Windsurf, Gemini, and Zed in seconds:

smriti install

(Or target specific tools: smriti install --client cursor,windsurf)

Step 2: Initialize a Codebase Workspace

Inside any repository, run:

smriti init

This automatically:

• Creates a dedicated Semantic Room in the Palace for the project (repo:<name>).
• Scaffolds .cursorrules, .cursor/rules/smriti.mdc, CLAUDE.md, and project .cursor/mcp.json.
• Installs a lightweight, non-blocking git post-commit hook that records recent commits and architectural changes into memory.

Git Commit Memory Hook Management:

smriti hook install    # Enable automatic commit context loggingsmriti hook uninstall  # Remove the post-commit hook

3. Python SDK

For application developers building custom agent loops.

pip install smriti-memcore[faiss] # FAISS is recommended for accelerated vector search

from smriti import SMRITI, SmritiConfig
# Initialize memory engine with OpenAIconfig = SmritiConfig(    storage_path="./my_agent_memory",    llm_model="gpt-4o",    openai_api_key="your-api-key-here")memory = SMRITI(config=config)
# Ingest observationsmemory.encode("User prefers using PyTorch for neural networks.")memory.encode("User is allergic to shellfish.", context="medical")
# Recall relevant context using multi-factor retrievalresults = memory.recall("What framework does the user prefer?")for mem in results:    print(f"[{mem.strength:.2f}] {mem.content}")
# Manually trigger System 2 background consolidationmemory.consolidate()memory.save()
# --- Or Load a Pre-Curated Persona (e.g. Albert Einstein) ---einstein, manifest = SMRITI.from_persona("albert-einstein")memories = einstein.recall("What thought experiment led to Special Relativity?")for mem in memories:    print(f"[{mem.strength:.2f}] {mem.content}")

MCP Tool Reference

SMRITI exposes 19 tools (13 native + 6 AMP aliases) for clients:

Core Tools

AMP v1.0 Alias Tools

These endpoints ensure complete conformance with the standard Agent Memory Protocol specification:

Framework Integrations

LangChain Integration

Use SmritiLangChainMemory as a drop-in replacement for default chat buffers. It limits active context using Working Memory and offloads the conversational history to the Semantic Palace graph in the background.

from langchain.chains import ConversationChainfrom smriti.integrations.langchain_memory import SmritiLangChainMemoryfrom smriti import SMRITI
smriti_engine = SMRITI(storage_path="./langchain_smriti_db")smriti_memory = SmritiLangChainMemory(smriti_client=smriti_engine, top_k=3)
conversation = ConversationChain(    llm=my_llm,    memory=smriti_memory,)conversation.predict(input="I prefer backend APIs in Python.")

Benchmarks & Performance

1. LoCoMo (Multi-System Context Retrieval)

Tested against four architectures on the LoCoMo long-context dialogue dataset (28 turns, 15 evaluation questions):

SMRITI retains high recall while drastically reducing query context size. Consolidation runs in the background and does not block client interactions.

2. LongMemEval (Long-Term Chat Sessions)

Evaluated over 50+ chat sessions using the LongMemEval harness:

Configuration Parameters

Initialize SmritiConfig with custom parameters to tune the cognitive weights:

from smriti import SmritiConfig
config = SmritiConfig(    working_memory_slots=7,          # Capacity limit (Miller's Law)        # Retrieval scoring weights (sum to 1.0)    recency_weight=0.2,    relevance_weight=0.4,    strength_weight=0.2,    salience_weight=0.2,
    # Forgetting & Temporal Decay    decay_rate=0.99,                 # Strength multiplier per day    strength_hard_threshold=0.05,    # Memories dropping below this are forgotten        # Palace Graph    room_merge_threshold=0.85,       # Cosine similarity for auto-merging semantic rooms)

Citation

If you use SMRITI in your research, please cite our technical paper:

@article{tyagi2025smriti,  title={SMRITI: A Scalable, Neuro-Inspired Architecture for Long-Term Event Memory in LLM Agents},  author={Tyagi, Shivam},  year={2025},  doi={10.13140/RG.2.2.25477.82407}}

License

SMRITI is licensed under the MIT License. See LICENSE for details.