A local-first, dual-process cognitive memory engine that gives AI agents persistent recall without blocking their real-time execution loop. Built with SQLite, vector search, and native Model Context Protocol (MCP) support.
Modular developer tooling to capture, inspect, and curate agent memory across your entire workflow.
The visual control deck. A standalone native macOS GUI to inspect real-time memory formation, trigger System 2 consolidation, and manage Obsidian sync.
Download .dmg (v1.0.0) →The spending monitor. A lightweight local proxy and native macOS menu bar widget tracking real-time API tokens and costs across Cursor, Claude Code, and custom agent swarms.
Download AIMeter.dmg (v0.3.9) →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 developer utilities built for the AI agent memory ecosystem.
Native macOS application with real-time memory visualizer, live daemon logs, Miller's Law slot monitor, and Obsidian vault sync controller.
The ultra-fast, local-first LLM API cost & token tracker for macOS. Real-time menu bar indicator, zero-latency proxy, and Claude Code watcher with local SQLite storage.
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.
Built to solve context bloat and hallucination limits of 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.
Deploy as an MCP server for AI coding agents, or embed directly via Python SDK.
# 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_installfrom 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
)Featured dispatches on GPU memory dynamics, LLM inference determinism, and cognitive agent architectures.
Loading featured dispatches...