Memory Bank MCP
Provides cross-platform support with automatic path normalization for Linux systems when managing Memory Bank files
Provides cross-platform support with automatic path normalization for macOS systems when managing Memory Bank files
Maintains persistent project context through structured markdown files organized into five core categories for tracking project information
Offers integration through a published npm package for easy installation and configuration of the Memory Bank MCP
Incorporates Shields.io badges in the README for displaying language options and other metadata
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., "@Memory Bank MCPupdate the decision log with our choice to use React hooks instead of class components"
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.
Memory Bank MCP
A guided Memory Bank plugin for AI-assisted development
Memory Bank MCP is a Model Context Protocol (MCP) plugin that helps AI assistants maintain persistent project context through structured markdown files. It provides a systematic approach to tracking project goals, decisions, progress, and patterns through guided instructions rather than direct operations.
Features
Guided Operations: Provides instructions for AI assistants to perform operations themselves
Structured Context Management: Organize project information across 5 core files
Intelligent Guidance: Step-by-step instructions for initialization and updates
Flexible Updates: Smart update guidance based on different change types
Cross-Platform Support: Automatic path normalization for Windows/macOS/Linux
MCP Configuration
Using the published npm package:
{
"mcpServers": {
"memory-bank": {
"command": "npx",
"args": ["@neko0721/memory-bank-mcp"],
"timeout": 600
}
}
}Related MCP server: codebase-memory
Quick Start
Initialize Memory Bank
Use init-memory-bank to create the memory-bank directory and core filesRead Memory Bank
Use get-memory-bank-info to view all Memory Bank contentUpdate Memory Bank
Use update-memory-bank to get guidance on updating specific files
Core Files
1. productContext.md (Product Context)
High-level project overview
Goals and key features
Overall architecture
Automatically incorporates projectBrief.md if available
2. activeContext.md (Active Context)
Current work status
Recent changes
Open questions and issues
Focus areas
3. progress.md (Progress)
Task tracking in checklist format
Completed, current, and planned tasks
Progress timeline
4. decisionLog.md (Decision Log)
Architectural and implementation decisions
Rationale and implications
Decision history
5. systemPatterns.md (System Patterns)
Recurring patterns and standards
Coding conventions
Architectural patterns
Testing strategies
Usage Guidelines
For AI Assistants
Start Every Session: Check if memory-bank directory exists, then use
get-memory-bank-infoto understand project stateInitialize When Needed: Use
init-memory-bankfor new projectsRead Context: Use
get-memory-bank-infoto understand project stateUpdate Guidance: Use
update-memory-bankto get update instructionsFollow Instructions: Execute the provided guidance to maintain Memory Bank
Update Triggers
Architecture Changes: Major structural decisions
Feature Completion: New features or capabilities
Bug Fixes: Significant issue resolutions
Refactoring: Code structure improvements
Decisions: Any important technical choices
Progress Updates: Task status changes
Tool Reference
init-memory-bank
Initializes Memory Bank with all core files.
Parameters:
rootPath: Project root directory pathforce(optional): Force re-initialization
Returns: Created files list and next steps guidance
get-memory-bank-info
Reads and returns all Memory Bank content (similar to codelf's get-project-info).
Parameters:
rootPath: Project root directory path
Returns: Formatted Memory Bank content for AI context
update-memory-bank
Provides guidance for updating Memory Bank files.
Parameters:
rootPath: Project root directory pathchangeType: Type of change (architecture/feature/bugfix/refactor/decision/progress)description: Brief description of the change
Returns: Detailed update instructions with templates and timestamps
Integration Tips
Cursor Setup
Add to Settings → Rules → User Rules:
Before starting any task, check if memory-bank directory exists in the project. If not, run the MCP command init-memory-bank.
Use the MCP command get-memory-bank-info to read Memory Bank content at session start.
After completing tasks or conversations, you must use the MCP command update-memory-bank to update Memory Bank content.
Follow the MCP guidance to maintain Memory Bank files.Windsurf Setup
Add to Settings → Cascade → Memories and Rules → Global Rules:
Before starting any task, check if memory-bank directory exists in the project. If not, run the MCP command init-memory-bank.
Use the MCP command get-memory-bank-info to read Memory Bank content at session start.
After completing tasks or conversations, you must use the MCP command update-memory-bank to update Memory Bank content.
Follow the MCP guidance to maintain Memory Bank files.Contributing
Contributions are welcome! Please feel free to submit issues or pull requests.
License
MIT
Acknowledgments
Inspired by the SPARC methodology and codelf.
Available Tools
3 toolsget-memory-bank-infoA
Read and return all Memory Bank file contents. This tool is similar to codelf's get-project-info:
Reads all .md files in the memory-bank directory
Returns formatted content for AI to understand project context
Use this tool at the beginning of each work session
| Name | Required | Description | Default |
|---|---|---|---|
| rootPath | Yes | Project root directory path Windows example: "C:/Users/name/project" macOS/Linux example: "/home/name/project" |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses that the tool reads files and returns formatted content, which is basic behavioral information. However, it lacks details on error handling (e.g., if the directory doesn't exist), performance implications (e.g., for large directories), or output structure beyond 'formatted content.'
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 front-loaded with the core purpose in the first sentence, followed by three bullet points that efficiently elaborate on scope, output, and usage without redundancy. Every sentence earns its place, and the structure is clear and concise.
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 low complexity (one parameter, no output schema, no annotations), the description is reasonably complete: it covers purpose, usage timing, and output intent. However, without annotations or an output schema, more detail on the return format (e.g., structure of 'formatted content') would enhance completeness for the 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 description coverage is 100%, so the schema fully documents the single parameter 'rootPath' with examples. The description adds no additional parameter information beyond what the schema provides, maintaining the baseline score of 3 for high schema coverage.
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 specific action ('Read and return all Memory Bank file contents'), identifies the resource ('.md files in the memory-bank directory'), and distinguishes from siblings by focusing on reading formatted content rather than initialization or updates. The comparison to 'codelf's get-project-info' further clarifies the purpose.
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?
Explicit guidance is provided: 'Use this tool at the beginning of each work session.' This directly tells the agent when to invoke it, and the mention of sibling tools (init-memory-bank, update-memory-bank) implies this is for reading existing content rather than creating or modifying it, though not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
init-memory-bankA
Initialize memory-bank directory and core files. This tool will:
Create memory-bank directory
Generate initial templates for 5 core files
Read and integrate projectBrief.md if it exists
Provide next steps guidance
| Name | Required | Description | Default |
|---|---|---|---|
| force | No | Force re-initialization (will overwrite existing files) | |
| rootPath | Yes | Project root directory path Windows example: "C:/Users/name/project" macOS/Linux example: "/home/name/project" |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly describes what the tool does (creates directory, generates files, reads projectBrief.md, provides guidance) and hints at overwriting behavior via the 'force' parameter. However, it does not cover potential side effects like file permissions, error handling, or specific output formats, leaving some behavioral aspects unspecified.
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 appropriately sized and front-loaded, starting with a clear purpose statement followed by a bulleted list of specific actions. Each sentence earns its place by adding value (e.g., detailing core file creation and projectBrief.md integration) without redundancy or unnecessary elaboration.
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 complexity (initialization with file operations), no annotations, and no output schema, the description is mostly complete. It covers key actions and parameters but lacks details on output (e.g., what 'next steps guidance' entails) and error scenarios. For a tool with 2 parameters and moderate complexity, it provides sufficient context but could be more thorough about behavioral outcomes.
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 both parameters ('force' and 'rootPath') with descriptions. The description does not add any additional meaning or context beyond what the schema provides, such as explaining how 'rootPath' interacts with the initialization process or default behaviors. Baseline 3 is appropriate as the schema handles parameter documentation adequately.
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's purpose with specific verbs ('Initialize', 'Create', 'Generate', 'Read and integrate', 'Provide') and resources ('memory-bank directory', 'core files', 'projectBrief.md', 'next steps guidance'). It distinguishes from siblings like 'get-memory-bank-info' (which likely reads) and 'update-memory-bank' (which likely modifies) by focusing on initial setup.
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 context (e.g., for initial setup of a memory bank) and mentions reading 'projectBrief.md if it exists', suggesting it's for new or existing projects. However, it lacks explicit guidance on when to use this tool versus alternatives like 'update-memory-bank' or 'get-memory-bank-info', and does not specify prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
update-memory-bankB
Generate detailed Memory Bank file update instructions with immediate execution guidance. This tool provides comprehensive, actionable instructions for updating Memory Bank files:
Detailed descriptions of each file's role and update strategy
Direct operation commands (not requests for confirmation)
Specific content templates and formatting guidelines
File relationship and update priority logic
Immediate execution emphasis for AI agents
| Name | Required | Description | Default |
|---|---|---|---|
| changeType | Yes | Type of change to determine update suggestions | |
| description | Yes | Brief description of the change | |
| rootPath | Yes | Project root directory path Windows example: "C:/Users/name/project" macOS/Linux example: "/home/name/project" |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It adds useful context: it generates 'detailed, actionable instructions' with 'direct operation commands (not requests for confirmation),' 'specific content templates,' and 'immediate execution emphasis.' This clarifies output format and urgency. However, it lacks details on permissions, side effects, or error handling, which are important for a tool that likely involves file updates.
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 well-structured and appropriately sized, with a clear opening sentence followed by bullet points that highlight key aspects. Each bullet adds value, such as detailing output components and execution emphasis. There's no redundant information, making it efficient, though it could be slightly more concise by integrating some points into the main sentence.
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 no annotations, no output schema, and a tool with 3 parameters (fully covered by schema), the description is moderately complete. It clarifies the tool's output format and urgency, which helps the agent understand what to expect. However, for a tool that likely involves file operations, it lacks details on potential side effects, success/failure indicators, or how the output should be used, leaving some gaps in context.
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 three parameters thoroughly. The description adds no specific information about parameters beyond implying they relate to 'update instructions.' It doesn't explain how parameters like 'changeType' or 'rootPath' influence the generated instructions, so it provides minimal value beyond the schema. Baseline 3 is appropriate given high schema coverage.
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's purpose: 'Generate detailed Memory Bank file update instructions with immediate execution guidance.' It specifies the verb 'generate' and resource 'Memory Bank file update instructions,' making the action clear. However, it doesn't explicitly differentiate from sibling tools like 'get-memory-bank-info' (likely for retrieval) or 'init-memory-bank' (likely for initialization), which slightly limits its distinction.
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 no guidance on when to use this tool versus alternatives. It mentions 'immediate execution emphasis for AI agents,' but this is a behavioral trait, not usage context. There's no indication of prerequisites, when to choose this over siblings, or any exclusions, leaving the agent without clear decision-making criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
3 tool updates
v1.0.0- First observed
get-memory-bank-info - First observed
init-memory-bank - First observed
update-memory-bank
TDQS
Each tool has a clearly distinct purpose with no overlap: get-memory-bank-info reads existing files, init-memory-bank creates the initial structure, and update-memory-bank provides instructions for modifications. The descriptions reinforce these distinct roles, making misselection unlikely.
All tool names follow a consistent verb-noun pattern with hyphens (get-memory-bank-info, init-memory-bank, update-memory-bank), using clear action verbs aligned with their functions. There are no deviations in naming style or convention.
Three tools are appropriate for the server's purpose of managing a memory bank, covering initialization, reading, and updating. However, the scope feels slightly thin as there is no tool for deleting or archiving files, which could be useful for lifecycle management.
The tools cover core operations for a memory bank system: initialization, reading, and updating. A minor gap exists in lacking a delete or archive tool for full lifecycle coverage, but agents can likely work around this by using update-memory-bank to modify content as needed.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Share one project context across ChatGPT, Claude, Telegram and any MCP client.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Portable AI memory shared across models and harnesses - plain markdown you own.
Persistent context for Claude. Your AI always knows your projects and next actions across sessions.
Related MCP Servers
- AlicenseAqualityDmaintenanceA Model Context Protocol implementation that enables AI assistants to interact with markdown documentation files, providing capabilities for document management, metadata handling, search, and documentation health analysis.142958MIT
- AlicenseNot gradedqualityDmaintenanceProvides persistent memory for AI coding agents through the Model Context Protocol, enabling them to store and retrieve project knowledge across sessions.33MIT
- AlicenseNot gradedqualityDmaintenanceGives AI agents durable project memory via the Model Context Protocol, allowing them to read tasks, record decisions, search context, and sync snapshots to the cloud.20MIT
- AlicenseAqualityCmaintenanceAn AI-first business and project management tool that stores data locally in Markdown and JSON files, exposed via the Model Context Protocol (MCP). Enables project, issue, client, contact, and note management through natural language.25MIT
Appeared in Searches
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/hoppo-chan/memory-bank-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server