# SMRITI Memory [Health: Active]

**Category:** 🧠 Knowledge & Memory  
**Repository:** https://github.com/smriti-memcore/smriti-memcore  
**GitHub Stars:** 3  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/smriti-memory

## Description
Neuro-inspired long-term memory for AI agents with semantic graph and consolidation.

## Tools
Capabilities this server exposes over MCP:

- **smriti_encode** — Ingests a new memory. Accept `private=True` to exclude from team syncs.
- **smriti_recall** — Retrieves memories using semantic and graph-based retrieval.
- **smriti_get_context** — Helper to inject the current active working memory slots into the context window.
- **smriti_how_well_do_i_know** — Performs a meta-memory confidence check on a given topic.
- **smriti_knowledge_gaps** — Identifies topics the agent has identified it needs more information on.
- **smriti_pin** — Marks a memory as permanent (protects it from strength decay).
- **smriti_forget** — Soft-deletes/archives a memory, leaving a cryptographic tombstone.
- **smriti_consolidate** — Triggers a background System 2 consolidation run.
- **smriti_stats** — Returns system-wide statistics (total memories, rooms, private counts).
- **smriti_create_private_room** — Spawns a private room. All memories inside this room are visibility-isolated.
- **smriti_open_ui** — Launches the interactive visual D3.js memory graph in your default browser.
- **smriti_sync_obsidian** — Exports the Semantic Palace graph structures to markdown files in an Obsidian Vault.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `uvx` (confidence: high):

```json
"mcpServers": {
  "smriti-memory": {
    "command": "uvx",
    "args": ["smriti-memcore"]
  }
}
```

## Documentation

## What SMRITI Memory does

SMRITI Memory provides long-term memory for AI agents through MCP. New interactions enter an append-only episode buffer, while a semantic retrieval layer connects memories by meaning and graph relationships. Retrieved information can be placed into a capacity-limited working-memory context, giving an agent a focused set of active items rather than requiring it to pass entire histories back into every prompt.

The memory model also includes meta-memory and privacy boundaries. Agents can check how well they know a topic, identify knowledge gaps, mark selected memories as permanent, and place data in private rooms or mark individual memories as private. Archived memories retain a cryptographic tombstone rather than disappearing without a trace.

## How it works

SMRITI uses two processing paths. The immediate path accepts raw interactions into the episode buffer without waiting for analysis. A separate consolidation process can later organize those entries into a Semantic Palace graph, identify relationships and skills, resolve contradictions, reflect on stored knowledge, and apply forgetting or spaced-repetition behavior.

Retrieval combines semantic and graph-based access. Working memory is described as holding seven plus or minus two slots, and `smriti_get_context` exposes the currently active slots for insertion into an agent context. `smriti_consolidate` starts a background System 2 consolidation run when an agent or operator wants to trigger one.

## Setup and configuration

Install the Python package and CLI with:

```bash
pip install smriti-memcore
```

The package requires Python 3.9 or newer. Ollama can be run locally for private, local LLM inference; the documented example uses the Mistral model. The CLI also supports packaging folders or declarative YAML/JSON specifications into `.smritibundle` archives and importing those bundles with `smriti pull`, though those workflows are separate from the MCP tools.

## Tools and capabilities

The MCP interface exposes:

- `smriti_encode` to ingest a memory, with a `private=True` option for excluding it from team synchronization.
- `smriti_recall` to search memories through semantic and graph-based retrieval.
- `smriti_get_context` to retrieve active working-memory slots for prompt context.
- `smriti_how_well_do_i_know` and `smriti_knowledge_gaps` for confidence and missing-information checks.
- `smriti_pin` to protect a memory from strength decay, and `smriti_forget` to archive it with a cryptographic tombstone.
- `smriti_consolidate` to trigger background consolidation.
- `smriti_stats` to return memory, room, and private-memory counts.
- `smriti_create_private_room` to create a visibility-isolated room.
- `smriti_open_ui` to launch a D3.js visual memory-graph interface in the default browser.
- `smriti_sync_obsidian` to export Semantic Palace graph structures as Markdown files in an Obsidian vault.

## Limitations and notes

Consolidation is asynchronous, so newly ingested information may not immediately have its final graph relationships or conflict resolution applied. Memory visibility depends on the selected private room or privacy flag. The system also applies strength decay unless a memory is pinned. Local Ollama inference is available as an option for privacy-focused deployments, but the MCP tool set itself does not require that workflow to be described as a client configuration.

_Full upstream README: https://allmcps.com/mcp/smriti-memory/readme_