AMP v1.0 Compliant

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_console
Online
guest@smriti:~$
Initialize SMRITI Engine... [OK]
Working Memory Slots (Miller's Law: 7 ± 2) ready.
System 2 Async Consolidation daemon listening on background.
SYSTEM 1: Episode Buffer Latency: <5ms
Waiting for ingestion...
SYSTEM 2: Semantic Palace Graph Async Daemon
The SMRITI Suite

The Complete Memory Ecosystem

A modular suite of tools designed to ingest, consolidate, visualize, and curate agent memory across your entire workflow.

SMRITI Core

Python SDK

The foundation. A high-performance LTM engine with multi-factor retrieval, salience filtering, and memory consolidation APIs for custom agent architectures.

SMRITI Daemon

Background Service

The pulse. An always-on, low-overhead background daemon that manages memory reflection, conflict resolution, and spaced-repetition decay when the agent is idle.

MCP Server

Model Context Protocol

The bridge. A native MCP server exposing 19 memory tools to developer environments like Claude Code, Cursor, Gemini Antigravity, and custom MCP clients.

Obsidian Sync

Vault Integration

The mirror. Automatically syncs and translates the agent's Semantic Palace Graph into clean markdown files inside an Obsidian vault for human curation.

Graph Explorer

D3.js Visualizer

The window. A built-in, responsive D3.js visualization dashboard with Prometheus metrics monitoring to analyze memory strength and recall latency.

Open Source & Standards

Standards & Developer Tooling

Open-source specifications and utilities built to advance the AI agent and codebase intelligence ecosystem.

Project
Description
Quick Install / Use
Link
AMP Logo Specification

Agent Memory Protocol (AMP)

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
CLI Tool

git-story

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
AI Security

mcp-guard

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
Observability

mcp-lens

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

The Dual-Process Architecture

SMRITI splits memory operations to match human cognitive processes, separating real-time execution from deep reflection.

01

Attention Gate

Every incoming observation passes through a local salience filter. Irrelevant noise is discarded immediately, protecting the agent's context window from pollution.

02

System 1 (Immediate Ingestion)

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.

03

System 2 (Async Consolidation)

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.

Raw Input Attention System 1 (LTM) Episode Buffer System 2 (LTM) Palace Graph

Engineered for Precision

A long-term memory engine built to solve the fundamental limits of RAG and standard vector databases.

01

Miller's Law Guard

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.

02

Private Rooms

Protect user privacy natively. Create localized semantic rooms. Memories tagged as `private` are isolated locally, preventing sensitive data from syncing to shared team storage.

03

Model Context Protocol

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.

04

Obsidian Sync

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.

05

Automatic Conflict Resolution

When new facts contradict old ones, System 2 background reflection resolves the conflict, updating outdated nodes and preserving historical context without duplicate entries.

06

Spaced Repetition & Decay

Memories have a dynamic **strength** value. Frequently recalled items are reinforced, while unused, low-salience details decay naturally over time, preventing database bloat.

Zero Friction Integration

Get started with SMRITI in minutes, whether as an MCP server or directly in your Python codebase.

Terminal
# 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
SMRITI automatically registers itself in your Claude, Gemini, or custom MCP config files.
python_sdk_example.py
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()
langchain_smriti.py
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
)