The Memory Bank MCP Server helps build and manage structured documentation for AI assistant environments using Cline's Memory Bank pattern. With this server you can:
Get detailed information about Memory Bank structure
Generate templates for specific Memory Bank files (e.g., projectbrief.md)
Analyze projects and provide suggestions for Memory Bank content
Provides deployment option for running the Memory Bank MCP Server in a containerized environment
Mentioned as one of the platforms powering the Memory Bank MCP Server, suggesting integration with Hyperskill's educational content or structure
All Memory Bank files are stored in Markdown format, with the MCP server providing templates and structure for these documents
Supports manual server setup using Python environment for running the Memory Bank MCP Server
Offers integration via SSE endpoint hosted on Replit for connecting to the Memory Bank MCP Server
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 MCP Server generate a memory bank template for my new React e-commerce 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.
This MCP server helps to build structured documentation system based on Cline's Memory Bank pattern for context preservation in AI assistant environments.
Powered by Enlighter and Hyperskill.
Learn how to setup and use Memory Bank directly in Cursor: http://enlightby.ai/projects/37
Get detailed information about Memory Bank structure
Generate templates for Memory Bank files
Analyze project and provide suggestions for Memory Bank content
Related MCP server: Roo Code Memory Bank MCP Server
There are a few options to use this MCP server:
Add this to your mcp.json config file:
{
"mcpServers": {
"mcp-memory-bank": {
"command": "uvx",
"args": [
"--from",
"git+https://github.com/ipospelov/mcp-memory-bank",
"mcp_memory_bank"
]
}
}
}Add this to your mcp.json config file:
{
"mcpServers": {
"memory-bank": {
"command": "npx",
"args": [
"-y",
"@smithery/cli@latest",
"run",
"@ipospelov/mcp-memory-bank",
"--key",
"your_smithery_key"
]
}
}
}Add this to your mcp.json config file:
{
"mcpServers": {
"memory-bank": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"19283744/mcp-memory-bank:latest"
]
}
}
}Clone repository and run the following commands:
python -m venv venv
source venv/bin/activate # On Windows: venv\Scripts\activate
pip install -r requirements.txtThen add this to your mcp.json config file:
{
"mcpServers": {
"memory-bank": {
"command": "python",
"args": ["src/mcp_memory_bank/main.py"]
}
}
}Ask Cursor or any other AI code assistant with Memory Bank MCP:
Create memory bank for To Do list application with your toolsProvide more context to get better results.
Returns a detailed description of the Memory Bank file structure.
Returns a template for a specific Memory Bank file.
Example:
{
"file_name": "projectbrief.md"
}Analyzes a project summary and provides suggestions for Memory Bank content.
Example:
{
"project_summary": "Building a React web app for inventory management with barcode scanning"
}The Memory Bank consists of core files and optional context files, all in Markdown format:
projectbrief.md - Foundation document that shapes all other files
productContext.md - Explains why the project exists, problems being solved
activeContext.md - Current work focus, recent changes, next steps
systemPatterns.md - System architecture, technical decisions, design patterns
techContext.md - Technologies used, development setup, constraints
progress.md - What works, what's left to build
memory_bank_instructions.md - How to work with Memory Bank, instructtions for AI-agent
Analyze a project summary and provide suggestions for Memory Bank content.
Args:
project_summary: A summary of the project
| Name | Required | Description | Default |
|---|---|---|---|
| project_summary | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool analyzes and provides suggestions, but doesn't describe how this works (e.g., is it AI-based, rule-based?), what the suggestions might include, or any constraints like rate limits, permissions needed, or output format. This leaves significant gaps in understanding the tool's behavior.
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 concise and well-structured, with the purpose stated upfront and parameter details in a clear 'Args' section. Both sentences earn their place by defining the tool's function and its single parameter. However, it could be slightly improved by integrating the parameter explanation more seamlessly into the main description.
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 lack of annotations and output schema, the description is incomplete for this tool's complexity. It doesn't explain what the suggestions look like, how they're formatted, or any behavioral traits. For an analysis tool with no structured output, more detail on the return value and process is needed to adequately guide an 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?
The schema description coverage is 0%, so the description must compensate. It adds minimal semantics by explaining 'project_summary' as 'A summary of the project', which clarifies the expected content but lacks details on format, length, or quality requirements. This provides some value beyond the bare schema but doesn't fully address the coverage gap, warranting a baseline score.
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: 'Analyze a project summary and provide suggestions for Memory Bank content.' It specifies the verb ('analyze') and resource ('project summary'), and indicates the output domain ('Memory Bank content'). However, it doesn't explicitly differentiate from sibling tools like 'generate_memory_bank_template' or 'get_memory_bank_structure', which prevents a perfect score.
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 doesn't mention the sibling tools or specify contexts where this analysis is preferred over generating templates or retrieving structures. The only implied usage is when a project summary is available, but this is too vague for effective tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate a template for a specific Memory Bank file.
Args:
file_name: The name of the file to generate a template for (e.g., "projectbrief.md")
| Name | Required | Description | Default |
|---|---|---|---|
| file_name | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions generating a template but does not specify what the template includes, how it is formatted, whether it overwrites existing files, or any permissions required. For a tool with no annotations, this leaves significant gaps in understanding its behavior and effects.
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, with a clear purpose statement followed by parameter details. It avoids unnecessary verbosity, but the parameter explanation could be more integrated into the main text rather than listed separately. Overall, it is efficient with minimal 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 the lack of annotations, no output schema, and low schema description coverage, the description is incomplete. It does not explain what the generated template looks like, how it is delivered, or any error conditions. For a tool that creates content, more context is needed to guide effective use.
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?
The description adds minimal meaning beyond the input schema. It explains that 'file_name' is 'The name of the file to generate a template for' and provides an example ('e.g., "projectbrief.md"'), which clarifies the parameter's purpose. However, with 0% schema description coverage, this is insufficient to fully compensate, as it doesn't detail constraints or expected formats beyond the example.
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 a template for a specific Memory Bank file.' It specifies the verb ('Generate') and resource ('template for a specific Memory Bank file'), making it easy to understand what the tool does. However, it does not explicitly differentiate from sibling tools like 'analyze_project_summary' or 'get_memory_bank_structure', which might offer related functionality.
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 lacks context about scenarios where generating a template is appropriate, prerequisites, or comparisons to sibling tools. This absence of usage instructions leaves the agent without clear direction on tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get a detailed description of the Memory Bank file structure.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves a 'detailed description,' implying a read-only operation, but doesn't specify aspects like authentication needs, rate limits, or what 'detailed' entails (e.g., format, depth). This leaves behavioral traits unclear, making it inadequate for a tool with zero annotation coverage.
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, clear sentence: 'Get a detailed description of the Memory Bank file structure.' It is front-loaded with the main action and resource, with no wasted words or redundant information. This makes it highly efficient and easy to understand.
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 (0 parameters, no output schema, no annotations), the description is minimally adequate. It states what the tool does but lacks details on behavior, output format, or usage context. Without an output schema, it doesn't explain return values, leaving gaps in completeness for a tool that might return complex structural information.
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?
The tool has 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description doesn't add parameter semantics, but with zero parameters, the baseline is 4. It appropriately avoids unnecessary details, though it doesn't compensate for any gaps since there are none.
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: 'Get a detailed description of the Memory Bank file structure.' It uses a specific verb ('Get') and resource ('Memory Bank file structure'), making the action and target explicit. However, it doesn't differentiate from sibling tools like 'analyze_project_summary' or 'generate_memory_bank_template', which prevents a score of 5.
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 doesn't mention sibling tools or contexts where this tool is preferred, such as for understanding file organization versus generating templates or analyzing summaries. This lack of explicit or implied usage guidelines results in a low score.
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 clearly distinct purpose: analyze_project_summary focuses on content suggestions, generate_memory_bank_template creates file templates, and get_memory_bank_structure describes the file structure. There is no overlap in functionality, making it easy for an agent to select the correct tool.
All tool names follow a consistent verb_noun pattern (e.g., analyze_project_summary, generate_memory_bank_template, get_memory_bank_structure) with clear verbs and descriptive nouns. The naming is uniform and predictable across all tools.
With only 3 tools, the server feels thin for a Memory Bank domain, which typically involves more operations like creating, updating, deleting, or searching content. While the tools cover analysis, template generation, and structure description, the count is borderline for comprehensive functionality.
The tool set has significant gaps for a Memory Bank server. It lacks core CRUD operations (e.g., create, read, update, delete Memory Bank files) and search capabilities, which are essential for managing and interacting with Memory Bank content. The current tools only support auxiliary functions, leading to potential agent failures in basic workflows.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Living technical memory for AI agents: recall approved project context, record what was learned.
Shared project context for AI agents and teams: docs, tasks, and messages that stay current.
Persistent docs and memory for AI agents — read, write, organize & search a shared workspace.
A persistent world-building memory your AI can read and write in any chat.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/ipospelov/mcp-memory-bank'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
