mcp-memento is a persistent, local memory server for AI assistants that stores and retrieves structured knowledge across sessions using a SQLite database.
Core Memory Operations
Store memories — Save notes, solutions, errors, code patterns, tasks, and other knowledge with types, tags, importance scores, and optional custom IDs
Retrieve a specific memory — Fetch a single memento by ID, optionally including its relationships
Update memories — Modify existing mementos (title, content, tags, importance, summary)
Delete memories — Remove a memento and all its relationships
Search & Recall
Natural language recall — Find memories using fuzzy, conceptual queries (e.g., "how does auth work")
Advanced filtered search — Precise retrieval using tags, memory types, importance thresholds, search tolerance (strict/normal/fuzzy), and match modes
Contextual scoped search — Search only within memories related to a specific memento
Relationship Management
Create relationships — Link two memories with typed relationships (e.g., SOLVES, CAUSES, REQUIRES, RELATED_TO) including strength and confidence scores
Get related memories — Traverse the knowledge graph to find connected memories by relationship type and depth
Search relationships by context — Filter relationships by structured context fields like scope, conditions, evidence, and components
Confidence & Knowledge Quality
Boost/adjust confidence — Reinforce or manually set confidence scores on relationships after verification or successful use
Apply confidence decay — Automatically decay confidence of stale relationships over time
Find low-confidence memories — Identify potentially obsolete or outdated knowledge for review or cleanup
Analytics & Onboarding
Get statistics — View counts and metadata about the entire memory database
Recent activity summary — See recent memory additions, unresolved problems, and activity by type
Onboarding guidance — Get retrieval flow optimization, best practices, and usage examples for integrating the tool into AI workflows
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., "@mcp-memento save that we're using React hooks for state management in this project"
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.
mcp-memento helps AI coding tools keep useful facts in one place. It gives your assistant a simple memory layer so it can hold on to notes, project details, and relationship links while you work.
Use it when you want your AI tool to remember things across sessions, track parts of a codebase, or keep a small knowledge base for a project. It stores data in SQLite, so your information stays in a local file on your computer.
Related MCP server: LumenCore
Open this page and get the app from there:
After you open the page, look for the latest release or the main download option.
Open the download page in your browser.
Get the Windows version of the app or package.
Save the file to your Downloads folder.
If Windows shows a security prompt, choose Keep or More info, then Run.
Follow the on-screen steps until setup finishes.
Start the app from the Start menu or from the folder where you saved it.
Download the file.
Move it to a folder you can find later.
Double-click the file to launch it.
Leave the data file in the same place so mcp-memento can keep your memory data.
mcp-memento works best on a modern Windows PC with:
Windows 10 or Windows 11
A recent version of Python 3 if you run it from source
Enough free space for a small SQLite database
Access to your AI coding tool or editor
It is built for local use, so it does not need a large setup. Most users only need to download it and connect it to their editor or agent tool.
Keeps notes for AI coding agents
Stores memory in a local SQLite database
Helps link related people, files, tasks, and ideas
Works as a Model Context Protocol server
Fits into editor and assistant workflows
Supports knowledge base style use
Keeps project context available over time
Helps reduce repeat explanations to your AI tool
mcp-memento is useful when an AI assistant keeps forgetting earlier details. Instead of repeating the same project notes, you can store them once and let the tool read them later.
Common uses include:
remembering project rules
storing file and folder notes
tracking code decisions
linking related tasks
keeping a small team knowledge base
giving an assistant a stable place to read and write context
If you downloaded a ready-to-run Windows file, open it and follow the prompts.
If you are using it with an editor or AI tool, connect it by adding the server details to that tool’s MCP settings. Many tools let you add a local server by pointing to the app file or a launch command.
Typical setup flow:
Download the app.
Start it on Windows.
Open your AI tool or editor.
Add mcp-memento as an MCP server.
Save the settings.
Test it by asking the assistant to save a note or recall a stored fact.
mcp-memento is made for tools that support the Model Context Protocol. That includes assistant apps and editors that can talk to local MCP servers.
When you connect it, your tool can:
read stored memory
save new facts
link items in your knowledge base
use past project context during future chats
If your editor has an extension panel, look for an MCP or server section. Add mcp-memento there and point it to the local app or executable you downloaded.
The app keeps data in structured form, which makes it easy to search and reuse. The database can hold:
notes
project facts
relationships between items
memory entries
reference links
working context for coding tasks
This makes it easier for an AI assistant to stay on task without losing earlier information.
Keep track of the parts of your app, your naming rules, and the decisions you already made.
Store design notes and return to them later without retyping everything.
Save facts about APIs, files, tools, and people in one local place.
Use it with your code editor so your assistant can read and write memory while you work.
mcp-memento is built to help your assistant find the right information fast. You can keep notes short and direct, then reuse them when needed.
Good items to store:
the purpose of a folder
what a function should do
project rules
known bugs
names of key files
links between features and tasks
Your memory data lives in SQLite on your machine. That makes it easy to back up, move, or inspect with other tools if needed.
Typical local storage benefits:
simple file-based storage
easy backup
easy restore
no complex server setup
works well for personal projects
After you connect mcp-memento, try a simple test:
Ask your assistant to save a note about your project.
Ask it to recall that note in a new chat.
Ask it to link two project items together.
Check that the answer uses the stored context.
If the assistant can save and recall the note, the setup is working.
This project fits into these areas:
ai-assistants
code-assistants
developer-tools
ide-integration
knowledge-base
mcp
mcp-server
persistent-memory
productivity-tools
python3
sqlite3
relationship-mapping
zed-extension
You may see files such as:
a Windows executable
a configuration file
a SQLite database file
a launch script
a README file
Keep the database file in a safe place if you want your memory to stay available between runs.
Use Downloads for the first install
Pin the app to Start if you use it often
Keep the data folder in one place
Back up the SQLite file before big changes
Close the app before moving its data file
If you are comfortable using Python 3, you can run the project from source on Windows.
Typical steps:
Install Python 3.
Download the repository files.
Open a terminal in the project folder.
Install the needed Python packages.
Start the server with the provided launch command.
Connect your AI tool to the local server.
If you are not using Python often, the Windows download is the easier path.
Check that the download finished
Try right-clicking and choosing Run as administrator
Make sure Windows did not block the file
Check the MCP settings in your editor
Confirm the app is running
Verify the path to the file is correct
Restart your editor after saving changes
Check that the SQLite database file stayed in the same folder
Make sure the app closed cleanly
Look for a save or sync action in your tool
Delete old copies from other folders
Use only the latest downloaded file
Start from the newest path you saved
Because mcp-memento stores data in a local SQLite file, backups are simple.
To back up your data:
Close the app.
Copy the database file to another folder.
Save the copy on a drive or cloud folder.
Restore it later by placing it back in the app folder.
When a new version is available, download it from the same project page and replace the old app if needed. Keep your database file in place so your stored memory stays intact.
Keep entries short and clear. Store one idea per note when you can. Use names that make sense to you and your assistant.
Good examples:
App uses local SQLite storage
Main UI folder holds shared components
Billing flow depends on auth state
Fix header spacing on mobile
AI tools work better when they can remember what matters. mcp-memento gives them a local place to store that context, so you do less repeat work and keep your project notes close at hand
Manually adjust confidence of a relationship.
Use for:
Correcting confidence scores when you know a memory is valid/invalid
Setting custom confidence based on verification
Overriding automatic decay for specific cases
Examples:
adjust_memento_confidence(relationship_id="rel-123", new_confidence=0.9, reason="Verified in production")
adjust_memento_confidence(relationship_id="rel-456", new_confidence=0.1, reason="Obsolete after library update")
Confidence ranges:
0.9-1.0: High confidence (recently validated)
0.7-0.89: Good confidence (regularly used)
0.5-0.69: Moderate confidence (somewhat outdated)
0.3-0.49: Low confidence (likely outdated)
0.0-0.29: Very low confidence (probably obsolete)
Inputs: relationship_id (required), new_confidence (required), reason.
Apply automatic confidence decay based on last access time.
Use for:
System maintenance to keep knowledge base fresh
Applying intelligent decay rules
Monthly confidence adjustment routine
Intelligent decay rules:
Critical memories (security, auth, api_key, password, critical, no_decay tags): NO DECAY
High importance memories: Reduced decay based on importance score
General knowledge: Standard 5% monthly decay (decay_factor=0.95)
Temporary context: Higher decay rate
Decay formula: monthly_decay = confidence × decay_factor^(months_since_last_access)
Minimum confidence: 0.1 (won't decay below this)
Returns:
Number of relationships updated
Summary of decay applied
Breakdown by memory type
Inputs: memory_id.
Boost confidence when a memory is successfully used.
Use for:
Reinforcing valid knowledge
Manual confidence increase for verified information
After successfully applying a solution
When verifying old information is still valid
Usage patterns:
After successfully applying a solution → boost its confidence
When verifying old information is still valid → boost confidence
When multiple team members confirm a pattern → boost confidence
Boost mechanics:
Base boost: +0.10 per access (capped at 1.0)
Additional boost for validation: +0.10 to +0.20
Maximum confidence: 1.0 (cannot exceed)
Inputs: memory_id (required), relationship_id, boost_amount, reason.
Search only within the context of a given memento (scoped search).
Two-phase process: (1) Find related memories, (2) Search only within that set. Provides semantic scoping without embeddings.
WHEN TO USE:
Searching within a specific problem context
Finding solutions in related knowledge
Scoped discovery
HOW TO USE:
Specify memory_id (context root)
Provide query (search term)
Optional: max_depth (default: 2)
RETURNS:
Matches found only within related memories
Context information
No leakage outside context
Inputs: memory_id (required), query (required), max_depth.
Link two mementos with a typed relationship.
Common types: SOLVES (solution→problem), CAUSES (cause→effect), ADDRESSES (fix→error), REQUIRES (dependent→dependency), RELATED_TO (general)
EXAMPLES:
create_memento_relationship(from_memory_id="sol-1", to_memory_id="prob-1", relationship_type="SOLVES")
create_memento_relationship(from_memory_id="err-1", to_memory_id="fix-1", relationship_type="CAUSES", context="Config error caused timeout")
Optional: strength (0-1), confidence (0-1), context (description)
Inputs: from_memory_id (required), to_memory_id (required), relationship_type (required), strength, +2 more.
Delete a memento and all its relationships
Inputs: memory_id (required).
Find memories with low confidence scores.
Use for:
Identifying potentially obsolete knowledge
Periodic cleanup and verification
Quality assurance of the knowledge base
Finding memories that need review
Features:
Filter by confidence threshold (default: < 0.3)
Shows relationships causing low confidence
Includes memory details and last access time
Sorted by confidence (lowest first)
Returns:
List of low confidence relationships with associated memories
Memory details for both ends of each relationship
Confidence scores and last access times
Inputs: threshold, limit.
Retrieve a specific memento by ID.
Use when you have a memory_id from search results or store_memento. Set include_relationships=true (default) to see connected memories.
EXAMPLE: get_memento(memory_id="abc-123")
Inputs: memory_id (required), include_relationships.
Get statistics about the memento database
Inputs: no named parameters.
Get summary of recent memento activity for session context.
Returns: memory counts by type, recent memories (up to 20), unresolved problems.
EXAMPLES:
get_recent_memento_activity(days=7) - last week's activity
get_recent_memento_activity(days=30, project="/app") - last month for specific project
Inputs: days, project.
Get comprehensive onboarding protocol for Memento including tool usage guidance, retrieval flow optimization, and best practices.
MEMENTO ONBOARDING PROTOCOL:
INITIALIZATION: Run memento_onboarding() at session start
RETRIEVAL FLOW:
Fact Check: Use search_mementos(tags=[...]) for simple identity/known facts
Complex Tasks: Use recall_mementos(query="...") for dev/architecture context
Fallback: If search fails, fallback to recall
AUTOMATIC STORAGE: Store via store_memento on git commits, bug fixes, version releases
ON-DEMAND TRIGGERS: Store instantly when user says "memento...", "remember...", etc.
MEMORY SCHEMA: Required tags (project, tech, category). Importance: 0.8+ (critical), 0.5 (standard)
OPTIMIZED RETRIEVAL (Avoid 6+ tool calls):
Target: 1-3 tool calls for simple info
Maximum: 5 tool calls for complex tasks
Follow decision tree: Known tags → search_mementos, Conceptual → recall_mementos
CRITICAL DISTINCTION: Memento vs Session memory
Memento: Long-term, cross-session, global scope
Session Memory: Temporary, project-specific, session-only
USE memento_onboarding(topic="...") for specific guidance:
"protocol": Full onboarding protocol
"retrieval_flow": Optimized retrieval guide
"distinction": Memento vs Session memory
"examples": Practical examples
"best_practices": Usage guidelines
Inputs: topic.
Primary tool for finding mementos using natural language queries.
Optimized for fuzzy matching - handles plurals, tenses, and case variations automatically.
BEST FOR:
Conceptual queries ("how does X work")
General exploration ("what do we know about authentication")
Fuzzy/approximate matching
USE FOR: Long-term knowledge that survives across sessions. DO NOT USE FOR: Temporary session context or project-specific state.
LESS EFFECTIVE FOR:
Acronyms (DCAD, JWT, API) - use search_mementos with tags instead
Proper nouns (company names, services)
Exact technical terms
EXAMPLES:
recall_mementos(query="timeout fix") - find timeout-related solutions
recall_mementos(query="how does auth work") - conceptual query
recall_mementos(project_path="/app") - memories from specific project
FALLBACK: If recall returns no relevant results, try search_mementos with tags filter.
Inputs: query (required), memory_types, project_path, limit, +1 more.
Search memento relationships by their structured context fields (scope, conditions, evidence, components)
Inputs: scope, conditions, evidence, components, +3 more.
Advanced search with fine-grained filters for precise retrieval of mementos.
USE THIS TOOL FIRST (not recall) when searching for:
Acronyms: DCAD, JWT, MCR2, API, etc.
Proper nouns: Company names, service names, project names
Known tags: When you know the tag from previous memories
Technical terms: Exact matches needed
PARAMETERS:
tags: Filter by exact tag match (most reliable for acronyms)
memory_types: Filter by type (solution, problem, etc.)
min_importance: Filter by importance threshold
search_tolerance: strict/normal/fuzzy
match_mode: any/all for multiple terms
NOTE: Tags are automatically normalized to lowercase for case-insensitive matching.
EXAMPLES:
search_mementos(tags=["jwt", "auth"]) - find JWT-related memories
search_mementos(tags=["dcad"]) - find DCAD memories by tag
search_mementos(query="timeout", memory_types=["solution"]) - timeout solutions
search_mementos(tags=["redis"], min_importance=0.7) - important Redis memories
For conceptual/natural language queries, use recall_mementos instead.
Inputs: query, terms, match_mode, tags, +7 more.
Store a new memento with context and metadata.
Required: type, title, content. Optional: id, tags, importance (0-1), context.
USE FOR: Long-term knowledge that should survive across ALL sessions. DO NOT USE FOR: Temporary session state or project-specific context.
LIMITS:
title: max 500 characters
content: max 50KB (50,000 characters)
tags: max 50 tags, 100 chars each
id: if provided, must be unique string identifier
TAGGING BEST PRACTICE:
Always include acronyms AS TAGS (e.g., tags=["jwt", "auth"])
Fuzzy search struggles with acronyms in content
Tags provide exact match fallback for reliable retrieval
Types: solution, problem, error, fix, task, code_pattern, technology, command, file_context, workflow, project, general, conversation
Note: decision is not a standalone type — use type="general" with tags=["decision", "architecture"].
Note: pattern is not a standalone type — use type="code_pattern".
EXAMPLES:
store_memento(type="solution", title="Fixed Redis timeout", content="Increased timeout to 30s...", tags=["redis"], importance=0.8)
store_memento(type="error", title="OAuth2 auth failure", content="Error details...", tags=["auth", "oauth2"], id="custom-error-123")
Returns memory_id. Use create_memento_relationship to link related memories.
Inputs: type (required), title (required), content (required), id, +4 more.
Update an existing memento
Inputs: memory_id (required), title, content, summary, +2 more.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 17 tools
Most tools have distinct purposes, such as search_mementos for precise tag-based retrieval and recall_mementos for fuzzy conceptual queries. However, some overlap exists, like adjust_memento_confidence and boost_memento_confidence both modifying confidence, which could cause confusion without careful reading of their descriptions.
Tool names follow a consistent snake_case pattern with clear verb_noun structures, such as get_memento, create_memento_relationship, and search_mementos. There are no deviations in naming conventions, making the set predictable and readable.
With 17 tools, the count is slightly high but reasonable for a memory management system covering storage, retrieval, relationships, and confidence adjustments. It feels comprehensive rather than bloated, though some tools like get_memento_statistics and get_recent_memento_activity might be borderline in necessity.
The tool set provides complete coverage for a memory system, including CRUD operations (store, get, update, delete), search (search_mementos, recall_mementos), relationship management (create, get, search), confidence handling (adjust, boost, decay), and utilities (statistics, onboarding). No obvious gaps exist for the domain.
Shared memory for coding agents. Stop re-explaining your codebase every session.
Persistent memory for AI assistants: store, search, and connect knowledge across conversations.
Private memory for AI agents: save and recall facts across Claude Code, Codex, Cursor and ChatGPT.
Persistent memory for Claude Code and Cursor. Stop re-explaining your project every session.