Cline Memory Bank
About
A memory system for Cline that tracks progress between conversations.
Explore
- Persistent project context management across coding sessions
- Tools for initializing memory bank, updating context, recording decisions, and tracking progress
- Resources for project context, active context, progress, and decisions
- Markdown file structure stored within the project directory
- System prompt integration for automated context checking
Setting up with Highlight
This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:
- Download and install Highlight from highlightai.com/download
- Navigate to the plugins tab and select "Add Custom Plugin"
-
Configure the plugin with the settings below
Plugin Name
Cline Memory BankCommand (node, npx, python, etc.)Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
- Enable "Start Automatically" if you want the plugin to start when Highlight launches
From the repository
- Node.js (v16 or later)
- VS Code with Cline extension installed
- TypeScript (for development)
1. Clone and build the server:
```bash
pnpm install
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.
1. 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'
});
2. 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'
}
}
});
3. 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'
]
}
});
4. 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']
}
});
Claude Desktop / Cursor
Paste into your MCP client config file to install this server.
{
"mcpServers": {
"cline memory bank": {
"cline-mcp-memory-bank": {
"command": "node",
"args": [
"build/index.js",
"initialize_memory_bank",
"."
]
}
}
}
}McpServers
{
"cline-mcp-memory-bank": {
"command": "node",
"args": [
"build/index.js",
"initialize_memory_bank",
"."
]
}
}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.
Table of Contents
- Overview
- Installation
- Prerequisites
- Setup Steps
- Features
- Tools
- Resources
- System Prompt for Cline
- File Structure
- Using With Cline
- Development
- Contributing
- License
Overview
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 --> MemBank
Persistent Memory System
One 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.
How It Works
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
Key Benefits
1. 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
2. Smart Context Management
- Automatically tracks important technical decisions
- Records project progress and milestones
- Maintains documentation of your development journey
3. Enhanced Productivity
- Faster project onboarding for each session
- More consistent and contextual AI assistance
- Reduces repetitive explanations
4. 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.
Installation
Prerequisites
- Node.js (v16 or later)
- VS Code with Cline extension installed
- TypeScript (for development)
Setup Steps
1. Clone and build the server:
```bash
Sign in to leave a review
Use Google, GitHub, or an email account so ratings stay tied to real people.
No reviews posted yet.
