この MCP サーバーは、AI アシスタント環境でのコンテキスト保存のために、Cline のメモリ バンク パターンに基づく構造化ドキュメント システムの構築に役立ちます。
EnlighterとHyperskillを搭載。
カーソルで直接メモリバンクを設定して使用する方法については、こちらをご覧ください: http://enlightby.ai/projects/37
メモリバンク構造の詳細情報を取得する
メモリバンクファイルのテンプレートを生成する
プロジェクトを分析し、メモリバンクのコンテンツに関する提案を行う
Related MCP server: Roo Code Memory Bank MCP Server
この MCP サーバーを使用するにはいくつかのオプションがあります。
mcp.json 構成ファイルに以下を追加します。
{
"mcpServers": {
"mcp-memory-bank": {
"command": "uvx",
"args": [
"--from",
"git+https://github.com/ipospelov/mcp-memory-bank",
"mcp_memory_bank"
]
}
}
}mcp.json 構成ファイルに以下を追加します。
{
"mcpServers": {
"memory-bank": {
"command": "npx",
"args": [
"-y",
"@smithery/cli@latest",
"run",
"@ipospelov/mcp-memory-bank",
"--key",
"your_smithery_key"
]
}
}
}mcp.json 構成ファイルに以下を追加します。
{
"mcpServers": {
"memory-bank": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"19283744/mcp-memory-bank:latest"
]
}
}
}リポジトリをクローンし、次のコマンドを実行します。
python -m venv venv
source venv/bin/activate # On Windows: venv\Scripts\activate
pip install -r requirements.txt次に、mcp.json 構成ファイルに以下を追加します。
{
"mcpServers": {
"memory-bank": {
"command": "python",
"args": ["src/mcp_memory_bank/main.py"]
}
}
}Memory Bank MCP を搭載した Cursor またはその他の AI コード アシスタントに質問します。
Create memory bank for To Do list application with your toolsより良い結果を得るには、より多くのコンテキストを提供してください。
メモリ バンク ファイル構造の詳細な説明を返します。
特定のメモリ バンク ファイルのテンプレートを返します。
例：
{
"file_name": "projectbrief.md"
}プロジェクトの概要を分析し、メモリ バンクのコンテンツに関する提案を提供します。
例：
{
"project_summary": "Building a React web app for inventory management with barcode scanning"
}メモリ バンクは、すべて Markdown 形式のコア ファイルとオプションのコンテキスト ファイルで構成されています。
projectbrief.md - 他のすべてのファイルの形を決める基礎文書
productContext.md - プロジェクトが存在する理由、解決しようとしている問題について説明します
activeContext.md - 現在の作業の焦点、最近の変更、次のステップ
systemPatterns.md - システムアーキテクチャ、技術的決定、設計パターン
techContext.md - 使用されたテクノロジー、開発設定、制約
progress.md - 何が機能し、何を構築するのか
memory_bank_instructions.md - メモリバンクの使い方、AIエージェントの指示
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.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
analyze_project_summarygenerate_memory_bank_templateget_memory_bank_structureScored across 3 tools
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.
Shared project memory that keeps teammates and AI agents aligned across sessions.
Shared project context for AI agents and teams: docs, tasks, and messages that stay current.
Bring your saved preferences, project decisions, and useful context into your next AI conversation.
Project memory for coding agents: requirements, decisions, code graph and delivery telemetry.
