Click on "Install 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-memory recall what we discussed about the deployment"
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.
Your AI agent forgets everything between sessions. This fixes that.
An MCP server that gives any AI agent persistent memory with semantic search. Store decisions, context, and knowledge once -- recall them with natural language queries across any future session.
Built on ChromaDB embeddings, scoped per project, runs entirely locally.
Every MCP-based agent (Claude Desktop, Claude Code, Cursor) starts each session with amnesia. Decisions made yesterday are gone. Context from last week is gone. You re-explain the same things every time.
mcp-memory adds four tools -- remember, recall, forget, list_memories -- that persist knowledge across sessions with vector similarity search. Your agent remembers what matters and finds it when relevant.
Related MCP server: aimemory
Semantic recall -- vector embeddings (all-MiniLM-L6-v2) find related memories, not just keyword matches
Per-project scoping -- memories don't leak between projects
Importance scoring -- prioritize critical decisions (1-5 scale)
Tag-based filtering -- organize memories by category
Fully local -- ChromaDB on disk, no cloud, no API keys, no telemetry
pip install -e .Environment Variable | Default | Description |
|
| Where memories are stored on disk |
|
| Default project scope |
|
| Default number of recall results |
Add to ~/.config/claude/claude_desktop_config.json:
{
"mcpServers": {
"memory": {
"command": "mcp-memory",
"env": {
"MCP_MEMORY_DATA_DIR": "~/.mcp-memory"
}
}
}
}Add to .claude/settings.json:
{
"mcpServers": {
"memory": {
"command": "mcp-memory"
}
}
}Store a memory for later recall.
Arg | Type | Default | Description |
| string | required | The text to remember |
| string | "global" | Project scope |
| list[string] | [] | Tags for filtering |
| string | "" | Where this memory came from |
| int | 3 | Priority 1-5 |
Search memories by semantic similarity.
Arg | Type | Default | Description |
| string | required | Natural language search |
| string | all | Limit to project |
| list[string] | none | Filter by tags |
| int | 10 | Max results |
| float | none | Minimum relevance 0.0-1.0 |
Delete stored memories.
Arg | Type | Default | Description |
| list[string] | none | Specific IDs to delete |
| string | none | Delete all in project |
| list[string] | none | Delete by tags |
Browse stored memories with pagination.
Arg | Type | Default | Description |
| string | all | Filter to project |
| list[string] | none | Filter by tags |
| int | 1 | Page number |
| int | 20 | Results per page |
pip install -e ".[dev]"
pytest # run tests
ruff check . # lint
ruff format . # format
mypy mcp_memory # type checkMIT
Delete stored memories. Specify at least one filter criterion.
| Name | Required | Description | Default |
|---|---|---|---|
| tags | No | Delete memories matching these tags. | |
| project | No | Delete all memories in this project scope. | |
| memory_ids | No | Specific memory IDs to delete. |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry behavioral disclosure. It states 'Delete' indicating destructiveness, but does not detail permanence, reversibility, authorization requirements, or effects on other users. This minimal transparency leaves the agent unaware of important behavioral traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description consists of two front-loaded sentences: the first states the primary action, the second provides a key constraint. Every word serves a purpose, with no redundancy or filler. It is appropriately sized for a simple deletion tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the destructive nature (no annotations) and three optional parameters, the description is insufficient. It does not clarify what happens if no filter is provided, whether deletions are cascading, or if confirmation is needed. An output schema exists but return values are not described. The brief text leaves significant gaps for an AI agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with each parameter described (tags, project, memory_ids). The description adds only the general constraint 'Specify at least one filter criterion,' which does not enhance understanding beyond the schema. Baseline 3 is appropriate as the schema already documents parameters well.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Delete stored memories,' which specifies the verb (delete) and resource (stored memories). It distinguishes from sibling tools (list_memories, recall, remember) by being the deletion tool. However, it could be more specific about what 'stored memories' encompasses (e.g., user-specific or global).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a constraint ('Specify at least one filter criterion') but offers no guidance on when to use this tool versus alternatives like list_memories or recall. It does not explain scenarios for deletion, prerequisites, or consequences.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Browse and list stored memories with optional filtering.
| Name | Required | Description | Default |
|---|---|---|---|
| page | No | Page number for pagination (starts at 1). | |
| tags | No | Filter to memories with these tags. | |
| project | No | Filter to a specific project (None = all projects). | |
| page_size | No | Number of results per page (default: 20). |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must convey all behavioral traits. It implies a read operation but does not mention pagination, result limits, or data sensitivity, though the schema hints at pagination. Adequate for a simple list but lacks explicit disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence with no waste. It is appropriately sized but lacks structured formatting that could improve scanability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (list with optional filtering), the description is mostly complete. An output schema exists, so return values are covered. No major gaps, but could mention pagination or read-only nature.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the description adds limited value beyond the schema. The phrase 'optional filtering' summarizes the filtering parameters but provides no additional semantic detail.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Browse and list stored memories with optional filtering' uses a specific verb (browse/list) and resource (memories), clearly distinguishing it from siblings like forget, recall, and remember.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for listing with optional filtering but provides no guidance on when to use this tool versus siblings or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search memories by semantic similarity.
Returns the most relevant stored memories.
| Name | Required | Description | Default |
|---|---|---|---|
| tags | No | Filter results to memories with these tags. | |
| query | Yes | Natural language search query. | |
| project | No | Limit search to a specific project (None = search all). | |
| n_results | No | Maximum results to return (default: 10). | |
| min_relevance | No | Minimum relevance score 0.0-1.0 to include. |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must fully disclose behavioral traits. It only states that it returns memories, without mentioning side effects, authorization needs, or whether it's read-only. This is minimal disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description consists of two concise, front-loaded sentences: the action and the result. Every word adds value, with zero waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 5 parameters (1 required) and full schema coverage plus an output schema, the description is adequate but minimal. It does not explain the semantic similarity mechanism or provide context beyond the basic purpose, leaving some gaps for a complex search tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all five parameters. The description adds no additional meaning beyond the schema, resulting in the baseline score of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool searches memories by semantic similarity and returns relevant results, using specific verbs 'search' and 'returns'. It distinguishes from siblings (forget, list_memories, remember) as a retrieval operation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use for semantic search, and sibling tool names clarify alternatives (e.g., 'list_memories' for listing, 'remember' for storing). However, no explicit when-not-to-use or criteria for choosing between tools is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Store a memory for later recall. Content is embedded for semantic search.
| Name | Required | Description | Default |
|---|---|---|---|
| tags | No | Optional tags for filtering (e.g. ["architecture", "decision"]). | |
| source | No | Optional note about where this memory came from. | |
| content | Yes | The text content to remember. | |
| project | No | Project scope for this memory (default: "global"). | |
| importance | No | Priority 1-5, where 5 is most important (default: 3). |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It mentions that content is embedded for semantic search, which is a key behavioral trait, but it does not disclose persistence, side effects, or any other behaviors beyond storage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence. Every word is necessary and adds value, with no wasted content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has an output schema (not shown but indicated), the description does not mention return values. It also does not guide usage of optional parameters like tags or importance, leaving some gaps for a complete understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has 100% description coverage for parameters. The tool description adds no additional parameter meaning beyond what the schema already provides, so a baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Store' and resource 'memory', clearly stating the action. It distinguishes from sibling tools like 'forget' (removal) and 'recall' (retrieval) by emphasizing storage for later recall.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use when you want to store a memory for later recall via semantic search, but it does not explicitly state when to use this tool versus alternatives like 'list_memories' or 'recall'. No when-not or exclusion criteria are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Each tool has a distinct purpose: remember stores, recall searches semantically, list_memories browses with filtering, and forget deletes. There is no overlap or ambiguity.
Most tools use single verb names (remember, recall, forget), but 'list_memories' breaks the pattern with a verb_noun style. The naming is clear but not fully consistent.
With 4 tools covering create, read (two retrieval methods), and delete, the count is well-scoped for a memory server. No tools feel redundant or missing.
The set covers create, read (list and search), and delete, but lacks an update operation. There is no way to modify an existing memory, which is a notable gap for a typical CRUD lifecycle.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Persistent memory for AI agents across Claude, ChatGPT and any MCP client.
Persistent memory for AI agents — log and recall conversation context over MCP.
Persistent memory for AI agents. Search, store, and recall across sessions.
Persistent memory for AI agents. Search and store durable facts, preferences and decisions.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/oneKn8/mcp-memory'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
