Cognitive Memory for Autonomous AI
SMRITI Memcore is a high-performance, neuro-inspired long-term memory engine. It gives your agents persistent, adaptive recall without blocking their real-time execution loop.
SMRITI Memcore is a high-performance, neuro-inspired long-term memory engine. It gives your agents persistent, adaptive recall without blocking their real-time execution loop.
A modular suite of tools designed to ingest, consolidate, visualize, and curate agent memory across your entire workflow.
The foundation. A high-performance LTM engine with multi-factor retrieval, salience filtering, and memory consolidation APIs for custom agent architectures.
The pulse. An always-on, low-overhead background daemon that manages memory reflection, conflict resolution, and spaced-repetition decay when the agent is idle.
The bridge. A native MCP server exposing 19 memory tools to developer environments like Claude Code, Cursor, Gemini Antigravity, and custom MCP clients.
The mirror. Automatically syncs and translates the agent's Semantic Palace Graph into clean markdown files inside an Obsidian vault for human curation.
The window. A built-in, responsive D3.js visualization dashboard with Prometheus metrics monitoring to analyze memory strength and recall latency.
Open-source specifications and utilities built to advance the AI agent and codebase intelligence ecosystem.
Specification
An open, community-driven specification defining a standard, vendor-agnostic interface for persistent memory in AI agents. Shares identical schemas across REST and MCP.
pip install amp-server
An interactive Git history and codebase architecture evolution slide-deck generator. Summarizes structural changes using LLMs and compiles them into portable HTML presentations.
pip install git-story
A lightweight local firewall and permission gateway proxy. Sits between AI editors (Cursor, Claude Code) and MCP servers, prompting for confirmation before executing dangerous commands.
npm install -g mcp-guard
A local visual workspace supervisor and topology mapper for MCP servers. Aggregates and tests active MCP servers configured across your environment from a single dashboard.
npx mcp-lens
SMRITI splits memory operations to match human cognitive processes, separating real-time execution from deep reflection.
Every incoming observation passes through a local salience filter. Irrelevant noise is discarded immediately, protecting the agent's context window from pollution.
Salient memories are instantly appended to the local **Episode Buffer** in under 5ms. The agent continues its execution loop without waiting for slow LLM processing or vector indexing.
When the agent is idle, background processes consolidate the raw episodes: extracting entities, building a **Semantic Palace Graph**, resolving contradictions, and applying temporal decay to weak memories.
A long-term memory engine built to solve the fundamental limits of RAG and standard vector databases.
Standard RAG floods context windows, causing LLM distraction. SMRITI bounds active working memory to **7 ± 2 slots**, ensuring only the most relevant, high-salience context is injected.
Protect user privacy natively. Create localized semantic rooms. Memories tagged as `private` are isolated locally, preventing sensitive data from syncing to shared team storage.
Ship memory out-of-the-box. SMRITI operates as a native MCP server, instantly integrating with Claude Code, Cursor, Gemini Antigravity, and custom agent systems.
Make your agent's mind human-readable. SMRITI automatically maps and syncs its semantic palace graph into a local Obsidian vault, allowing you to curate, edit, and visualize memories.
When new facts contradict old ones, System 2 background reflection resolves the conflict, updating outdated nodes and preserving historical context without duplicate entries.
Memories have a dynamic **strength** value. Frequently recalled items are reinforced, while unused, low-salience details decay naturally over time, preventing database bloat.
Get started with SMRITI in minutes, whether as an MCP server or directly in your Python codebase.
# Method A: Install using the one-line bash installer
bash <(curl -s https://raw.githubusercontent.com/smriti-memcore/smriti-memcore/main/install_smriti_mcp.sh)
# Method B: Install via PyPI and run CLI setup
pip3 install smriti-memcore
smriti_install
from smriti import SMRITI, SmritiConfig
# 1. Initialize SMRITI LTM Engine
config = SmritiConfig(
storage_path="./agent_memory",
llm_model="gpt-4o",
openai_api_key="your-key-here"
)
memory = SMRITI(config=config)
# 2. Ingest observations (System 1 - Instant)
memory.encode("User prefers using PyTorch for neural networks.")
memory.encode("User is allergic to shellfish.", context="medical", private=True)
# 3. Query relevant context with dynamic retrieval
results = memory.recall("What framework does the user prefer?")
for mem in results:
print(f"[{mem.strength:.2f}] {mem.content}")
# 4. Trigger System 2 Background Consolidation
memory.consolidate()
memory.save()
from langchain.agents import AgentExecutor, create_openai_tools_agent
from smriti.integrations.langchain import SmritiLangChainMemory
# Create SMRITI wrapper for LangChain
smriti_memory = SmritiLangChainMemory(
storage_path="./langchain_ltm",
api_key="your-key-here"
)
# Integrates directly into your LangChain Agent Executor
agent_executor = AgentExecutor(
agent=agent,
tools=tools,
memory=smriti_memory, # SMRITI handles working & long-term memory
verbose=True
)