Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Mnemonic remember that I prefer direct answers"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Persistent memory management for Claude and other AI assistants. Give your AI a brain that remembers.
Born from the Claude Memory Architecture research project.
# Using uvx (recommended)
uvx mnemonic-memory
# Or pip
pip install mnemonic-memoryRelated MCP server: SAE4U Memory
Add to your Claude Code MCP config (~/.claude.json or project .claude/settings.json):
{
"mcpServers": {
"mnemonic": {
"command": "uvx",
"args": ["mnemonic-memory"]
}
}
}Or with pip-installed version:
{
"mcpServers": {
"mnemonic": {
"command": "mnemonic"
}
}
}Tool | Description |
| Create a new memory with tags and triggers |
| Retrieve a memory by ID |
| Update an existing memory |
| Permanently delete a memory |
| Full-text search with tag filtering |
| List all memories with sorting |
| Pin important memories |
| Export all memories to JSON |
| Import from a previous export |
| View memory statistics |
Semantic Search: Find memories by meaning, not just keywords
Auto-Decay: Memories fade based on access patterns
Consolidation: Automatically merge similar memories
Maintenance: Clean up stale data
mnemonic_create({
"title": "Bash's communication preferences",
"content": "Direct and concise. Lead with conclusions (Minto Pyramid). No fluff.",
"tags": ["preferences", "communication"],
"triggers": ["how should I respond to bash"]
})# Full-text search
mnemonic_search({"query": "communication preferences"})
# Filter by tags
mnemonic_search({"tags": ["preferences"]})
# Combined
mnemonic_search({"query": "direct", "tags": ["communication"]})mnemonic_pin({"id": "abc-123", "pinned": true})Memories are stored in ~/.mnemonic/memories.db (SQLite).
Override with MNEMONIC_DATA_DIR environment variable:
export MNEMONIC_DATA_DIR="/custom/path"memories
├── id (TEXT, UUID)
├── type (TEXT, default 'memory')
├── title (TEXT)
├── content (TEXT)
├── weight (REAL, 0.1-1.0)
├── pinned (BOOLEAN)
├── emotional_flag (BOOLEAN)
├── created_at (TEXT, ISO timestamp)
├── updated_at (TEXT)
├── last_accessed_at (TEXT)
├── access_count (INTEGER)
├── status (TEXT: active, archived)
└── metadata (JSON)
tags
├── id (INTEGER)
└── name (TEXT, unique)
memory_tags (many-to-many)
triggers
├── id (INTEGER)
├── memory_id (TEXT)
└── phrase (TEXT)This project implements the Claude Memory Architecture research:
Weighted memories: Not all memories are equal (0.1-1.0 weight)
Memory decay: Unused things fade (premium feature)
Depth on demand: Load summaries, expand when needed
Trigger-based recall: Phrases that surface relevant memories
# Clone
git clone https://github.com/bashoh/mnemonic-memory
cd mnemonic-memory
# Install with dev dependencies
pip install -e ".[dev]"
# Run locally
python -m mnemonicMIT
Built by Bash @ Wishly Group
"Current AI assistants have Alzheimer's. Let's fix that."
Create a new memory.
Use this to store important information that should persist across sessions. Memories can be tagged for organization and have trigger phrases that surface them when relevant topics come up.
Example: - Title: "Bash's communication style" - Content: "Direct, concise, no fluff. Lead with conclusions." - Tags: ["preferences", "user-profile"] - Triggers: ["how does bash like responses"]
Inputs: params (required). Returns: result
Permanently delete a memory.
This cannot be undone. Consider setting status to 'archived' instead if you might need the memory later.
Inputs: params (required). Returns: result
Export all active memories to JSON.
Returns a complete export that can be imported later or backed up. Useful for:
Backing up memories
Transferring to another system
Debugging
Inputs: no named parameters. Returns: result
Get a single memory by its ID.
Returns the full memory including content, tags, triggers, and metadata. Also records that the memory was accessed (updates access count and timestamp).
Inputs: params (required). Returns: result
Import memories from a previous export.
The data must be in the export format with a 'memories' array.
Options:
overwrite: If true, updates existing memories with matching IDs If false, skips memories that already exist
Returns statistics about the import operation.
Inputs: params (required). Returns: result
List all memories with optional filtering and sorting.
Use this for browsing memories rather than searching. Returns paginated results with metadata.
Inputs: params (required). Returns: result
Pin or unpin a memory.
Pinned memories:
Won't decay in weight over time (premium feature)
Are prioritized in search results
Useful for critical information like user preferences
Inputs: params (required). Returns: result
Search memories using full-text search and/or tag filtering.
The query searches both title and content using SQLite FTS5. Results are ranked by relevance and weight.
Examples: - query: "wishly deals" # Find memories about Wishly deals - tags: ["project"] # All memories tagged 'project' - query: "API", tags: ["technical"] # Combine search and filtering
Inputs: params (required). Returns: result
Get memory statistics.
Returns:
Total memory count by status
Weight distribution
Most used tags
Pinned/emotional counts
Useful for understanding your memory landscape.
Inputs: no named parameters. Returns: result
Update an existing memory.
Only specified fields will be updated. Tags and triggers are replaced entirely if provided (not merged).
Example: - id: "abc-123" - weight: 0.95 # Increase importance - tags: ["high-priority"] # Replace existing tags
Inputs: params (required). Returns: result
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 10 tools
Each tool targets a distinct operation: create, get, update, delete, search, list, pin, export, import, stats. Search and list are differentiated by intent (query-based vs. browsing), and all other actions are unambiguous.
All tools follow a consistent 'mnemonic_<verb>' pattern (e.g., mnemonic_create, mnemonic_get, mnemonic_update). The verb is clear and the naming is uniform.
10 tools is well-scoped for a memory management server. It covers all core CRUD operations plus search, organization (pin), data portability (export/import), and analytics (stats) without bloat.
The tool set provides complete lifecycle coverage for memories: create, read, update, delete, search, list, plus additional features like pinning, export/import, and statistics. No significant gaps are apparent.
Persistent memory for AI assistants: store, search, and connect knowledge across conversations.
Persistent memory for AI agents across Claude, ChatGPT and any MCP client.
Persistent AI memory shared across Claude, ChatGPT, coding agents, and compatible MCP clients.
Private persistent memory for Claude, ChatGPT & Gemini via MCP - semantic search, zero-code setup.
