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., "@Cline Memory Bank update memory bank with current session progress"
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.
Inspired by roo-code-memory-bank
This project is still in development but is mostly working.
A Model Context Protocol server that provides persistent project context management for AI-assisted development - specifically designed to work with Cline VSCode Extenson.
Related MCP server: MCP Python Toolbox
The Memory Bank MCP server helps maintain consistent project context across development sessions by providing structured tools and resources for managing:
Project context and technical details
Current session state and tasks
Progress tracking and milestones
Technical decisions and rationale
graph LR
VSCode[VS Code + Cline] --> MemBank[Memory Bank Server]
MemBank --> Files[Markdown Files]
Files --> Context[Project Context]
Files --> Progress[Progress Tracking]
Files --> Decisions[Decision Log]
AI[AI Assistant] --> Files
VSCode --> AI
AI --> MemBankOne of the most powerful features of this project is its ability to maintain context across different coding sessions. Think of it as giving your AI assistant a "memory" that doesn't forget what you've been working on, even when you close VSCode and come back later.
Imagine you're working on a complex project that spans multiple days or weeks. Normally, each time you start a new coding session, you'd need to re-explain your project's context to the AI assistant. With the Memory Bank:
graph LR
Session[New Session] --> Load[Load Context]
Load --> Read[Read Files]
Read --> Update[Update Context]
Update --> Write[Write Changes]
Write --> Track[Track Progress]
Track --> Record[Record Decisions]
Record --> Ready[Ready for Tasks]Your AI assistant remembers previous discussions and decisions
Maintains understanding of your project's architecture and goals
Keeps track of ongoing tasks and progress
Remembers your coding preferences and project conventions
Continuity Across Sessions
No need to re-explain your project every time
Pick up exactly where you left off
Maintains consistent understanding of your codebase
Smart Context Management
Automatically tracks important technical decisions
Records project progress and milestones
Maintains documentation of your development journey
Enhanced Productivity
Faster project onboarding for each session
More consistent and contextual AI assistance
Reduces repetitive explanations
Project History
Keeps track of why certain decisions were made
Maintains a log of completed features and changes
Helps new team members understand project evolution
The Memory Bank seamlessly integrates with the Cline VSCode Extension, requiring no additional setup from you once configured. It works quietly in the background, ensuring your AI assistant always has the context it needs to provide relevant and helpful assistance.
Node.js (v16 or later)
VS Code with Cline extension installed
TypeScript (for development)
Clone and build the server:
# Clone the repository
git clone https://github.com/dazeb/cline-mcp-memory-bank
cd cline-mcp-memory-bank
# Install dependencies (using pnpm as recommended)
pnpm install
# Build the server
pnpm run build
# Make globally available (optional, requires pnpm setup for global linking)
# pnpm link --global Configure Cline Extension (Recommended: Use Initialization Command):
Recommended Method: After building, run the initialization command from the project root. This automatically creates the memory bank files and configures the Cline MCP settings for you:
node build/index.js initialize_memory_bank . Manual Method (If needed): Add the following to your Cline MCP settings file. The path varies by OS:
Linux: ~/.config/Code - Insiders/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
macOS: ~/Library/Application Support/Code - Insiders/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
Windows: %APPDATA%\Code - Insiders\User\globalStorage\saoudrizwan.claude-dev\settings\cline_mcp_settings.json
Add this JSON object:
{
"mcpServers": {
"memory-bank": {
"command": "node",
"args": [
"/path/to/cline-memory-bank/build/index.js"
],
"disabled": false,
"autoApprove": []
}
}
}Replace /path/to/cline-memory-bank with the actual, absolute path to your server installation (e.g., C:\Users\YourUser\Projects\cline-mcp-memory-bank on Windows). Note: Using the initialization command above handles this automatically.
After installation and building, initialize the memory bank for your project by running this command in the project's root directory:
node /path/to/cline-mcp-memory-bank/build/index.js initialize_memory_bank .(Replace /path/to/cline-mcp-memory-bank with the actual path where you cloned and built the server).
Alternatively, if the server is configured in Cline, you can ask Cline to run the tool: initialize the memory bank.
Once initialized, you can ask Cline to update the memory bank context, record decisions, or track progress using the tools below, or configure it via .clinerules or the system prompt.
initialize_memory_bank
Creates Memory Bank structure for a new project
Creates required markdown files with initial templates
use_mcp_tool('memory-bank', 'initialize_memory_bank', {
projectPath: '/path/to/project'
});update_context
Updates active context with current session information
Tracks mode, tasks, and session state
use_mcp_tool('memory-bank', 'update_context', {
projectPath: '/path/to/project',
content: {
currentSession: {
date: '2025-03-13',
mode: 'development',
task: 'Implementing new feature'
}
}
});record_decision
Records technical decisions with rationale
Maintains history of architectural choices
use_mcp_tool('memory-bank', 'record_decision', {
projectPath: '/path/to/project',
decision: {
title: 'Authentication System',
description: 'Implementing JWT-based authentication',
rationale: 'Better scalability and stateless operation',
alternatives: [
'Session-based auth',
'OAuth only'
]
}
});track_progress
Updates project progress and milestones
Manages task status and blockers
use_mcp_tool('memory-bank', 'track_progress', {
projectPath: '/path/to/project',
progress: {
completed: ['Setup project', 'Initialize database'],
inProgress: ['Implement auth', 'Create API routes'],
blocked: ['Deploy to production']
}
});memory://project/context
Project overview and technical stack
Architecture principles and guidelines
memory://active/context
Current session state and tasks
Active considerations and notes
memory://progress
Project milestones and task tracking
Work status and blockers
memory://decisions
Technical decisions and rationale
Architecture choices and alternatives
Add to Cline system prompt or .clinerules file under settings.
Memory Bank Integration Rules:
CRITICAL: Before ANY task or response:
1. ALWAYS check active context (memory://active/context):
- Current project state and mode
- Ongoing tasks and their status
- Recent decisions and updates
- Open questions and concerns
2. ALWAYS review project context (memory://project/context):
- Technical stack and dependencies
- Project guidelines and standards
- Architecture principles
- Development workflow
3. ALWAYS consult decision log (memory://decisions) for:
- Previous architectural choices
- Established patterns
- Technical rationales
- Related decisions
4. ALWAYS check progress tracking (memory://progress):
- Current phase and milestones
- Completed work
- In-progress tasks
- Known blockers
After EVERY task:
1. Update active context with:
- Task completion status
- New information learned
- Changes made
2. Record any technical decisions with:
- Clear rationale
- Considered alternatives
- Impact assessment
3. Update progress tracking:
- Mark completed items
- Add new tasks identified
- Note any blockers found
Key Guidelines:
- NEVER proceed without checking memory bank context
- ALWAYS maintain consistent project state
- Record ALL significant technical decisions
- Track progress in real-time
- Keep context updated with EVERY changeWhen initialized, the Memory Bank creates the following structure in your project:
graph LR
Root[Project Root] --> Bank[memory-bank]
Bank --> PC[projectContext.md]
Bank --> AC[activeContext.md]
Bank --> P[progress.md]
Bank --> DL[decisionLog.md]
PC --> Stack[Technical Stack]
AC --> Tasks[Active Tasks]
P --> Status[Project Status]
DL --> History[Decision History]Upon initialization, each file is populated with structured content:
activeContext.md:
Current session information with timestamp
Initial tasks (Project initialization, Environment setup)
Open questions about project goals and requirements
Recent updates section
progress.md:
Current phase (Initialization)
Initial completed tasks (Repository setup, Basic structure)
In-progress tasks (Environment configuration, Documentation)
Upcoming tasks section
Blockers tracking
decisionLog.md:
Initial project structure decisions
Development workflow choices with alternatives
Documentation strategy decisions
Section for pending decisions
projectContext.md:
Project overview and version
Detected technical stack and dependencies
Configuration files listing
Architecture principles
Development setup instructions
Project workflow guidelines
graph LR
Start[Start] --> Init[Initialize]
Init --> Context[Load Context]
Context --> Update[Make Changes]
Update --> Progress[Track Progress]
Progress --> Record[Record Decisions]
Record --> Sync[Auto Sync]
Sync --> ContextSimply ask Cline to initialize the memory bank.
Initialize a new Memory Bank:
use_mcp_tool('memory-bank', 'initialize_memory_bank', {
projectPath: process.cwd() // or specific path
});Access project context:
access_mcp_resource('memory-bank', 'memory://project/context');Update session context:
use_mcp_tool('memory-bank', 'update_context', {
projectPath: process.cwd(),
content: {
currentSession: {
date: new Date().toISOString().split('T')[0],
mode: 'development',
task: 'Current task description'
}
}
});Record technical decisions:
use_mcp_tool('memory-bank', 'record_decision', {
projectPath: process.cwd(),
decision: {
title: 'Decision Title',
description: 'What was decided',
rationale: 'Why it was decided'
}
});To modify or enhance the server:
Update source in src/index.ts
Run tests: npm test
Build: npm run build
Restart Cline extension to load changes
Contributions are welcome! Please:
Fork the repository
Create a feature branch
Make your changes
Submit a pull request
MIT © dazeb
Initialize Memory Bank structure for a project
| Name | Required | Description | Default |
|---|---|---|---|
| projectPath | Yes | Path to project root directory |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It only says 'Initialize', which implies a setup operation, but does not mention whether it is destructive (e.g., overwriting existing structures), idempotent, or what files or directories are created. This is insufficient for an agent to understand the side 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 a single, front-loaded sentence that directly states the action. Every word adds value, with no unnecessary elaboration. It is appropriately 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?
For a simple tool with one parameter and no output schema, the description is minimally complete. It explains what the tool does but lacks details about the resulting structure or any constraints. Could benefit from mentioning what exactly is created (e.g., files, folders) to achieve full clarity.
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% for the single parameter 'projectPath', so the baseline is 3. The description does not add additional meaning beyond the schema, but the parameter is self-explanatory. No enhancement is provided.
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 action ('Initialize') and resource ('Memory Bank structure'), making the purpose straightforward. However, it does not differentiate from sibling tools like 'record_decision' or 'update_context', which have distinct purposes, so the score is 4 rather than 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?
No guidance is provided on when to use this tool versus alternatives, such as when a project is first set up or after adding a new project root. There are no contextual clues about prerequisites or scenarios where initialization should be avoided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Add a new technical decision with rationale and metadata
| Name | Required | Description | Default |
|---|---|---|---|
| projectPath | Yes | Path to project root directory | |
| decision | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full behavioral disclosure burden. It only states 'Add...' without detailing side effects, permissions, idempotency, or error conditions.
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?
Single sentence, no fluff, action placed first. Every word serves purpose.
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?
For a tool with a nested object parameter and no output schema, the description is too brief. It omits what happens after adding (e.g., persistence, return value) and does not cover edge cases or side effects.
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 no meaning beyond the input schema. Although the nested 'decision' object has detailed subfield descriptions, the top-level parameter 'decision' lacks a description, and the tool description does not compensate for this gap.
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 action ('Add') and the resource ('technical decision') with specifics ('rationale and metadata'), distinguishing it from siblings like 'track_progress' or 'initialize_memory_bank'.
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 recording decisions but provides no explicit guidance on when to use this tool versus alternatives, nor any exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Update project progress and milestones
| Name | Required | Description | Default |
|---|---|---|---|
| projectPath | Yes | Path to project root directory | |
| progress | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It only says 'Update' but does not disclose whether updates are incremental or replace, side effects, or validation rules. Lacks key behavioral details.
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?
Single sentence, front-loaded with verb and resource. No wasted words, though could be more informative while remaining 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 absence of output schema and annotations, the description should cover more context (e.g., return value, side effects). It is too brief for a tool with nested objects and required parameters.
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 50% (only projectPath has a top-level description). The description adds no meaning to parameters; the progress object sub-fields have schema descriptions but not explained in the tool description. Fails to compensate for low 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 it updates project progress and milestones, which is a specific verb-resource pairing. It distinguishes from sibling tools (e.g., initialize_memory_bank, record_decision) as they target different aspects, but lacks explicit differentiation.
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?
No guidance on when to use this tool versus alternatives, no context about prerequisites or exclusions. Simply states action without usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Update active context with current session information
| Name | Required | Description | Default |
|---|---|---|---|
| projectPath | Yes | Path to project root directory | |
| content | Yes | Current session context to update |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description carries the full burden of disclosing behavioral traits. It only says 'update' but does not explain whether it merges or replaces, what happens to existing context, or any side effects. This is insufficient for a mutation tool.
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 that conveys the core action efficiently. No unnecessary words are present.
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 nested schema, no output schema, and no annotations, the description lacks completeness. It does not explain the update behavior (merge vs replace), return value, or error conditions, leaving important gaps.
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%, so the description adds little beyond what's already in the schema. It mentions 'current session information', which aligns with the content.currentSession object, but doesn't elaborate on parameter formats or constraints.
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 action ('Update') and the resource ('active context') with the specific information ('current session information'). It effectively communicates the tool's purpose and is distinguishable from sibling tools like initialize_memory_bank or record_decision.
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 like initialize_memory_bank or track_progress. There is no mention of prerequisites or scenarios where the tool should not be used.
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 clear, distinct purpose: initialization, decision recording, progress tracking, and context updating with no overlaps.
All tool names follow a consistent verb_noun pattern in lowercase snake_case, making them predictable.
Four tools are well-scoped for a memory bank server, covering essential operations without excess or deficiency.
Core memory bank operations are covered, but retrieval and search capabilities are missing, which is a minor gap.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
A Model Context Protocol server for Wix AI tools
Share one project context across ChatGPT, Claude, Telegram and any MCP client.
Model Context Protocol server for the Apideck Unified API. Connect any MCP-compatible agent framework to 100+ accounting systems, HRIS platforms, file storage providers, and more through one integration. More information https://www.apideck.com/mcp-server
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/dazeb/cline-mcp-memory-bank'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
