The Memory Bank MCP-with-SSH server enables AI assistants to manage structured repositories of information (Memory Banks) across sessions, with support for remote SSH storage. You can:
Initialize and Configure: Create Memory Banks in specified directories and set custom paths
File Operations: Read, write, and list files within a Memory Bank
Progress Tracking: Log and update project progress in Memory Bank files
Context Management: Update active context with current tasks, issues, and next steps
Decision Logging: Record decisions with alternatives and consequences
Mode Switching: Switch between operational modes (code, architect, debug, test, ask)
Status and Debugging: Check Memory Bank status and debug configurations
Remote Storage: Store and manage Memory Banks on remote servers via SSH (requires SSH key authentication)
File Migration: Migrate between file naming conventions
Allows CI/CD integration through GitHub Actions, as shown by the test workflow badge in the README.
Uses markdown for structured information storage, organizing project data into markdown files for context management across sessions.
Provides package distribution through npm registry, enabling installation via npm commands and integration with package.json workflows.
Implements semantic versioning rules to automatically manage version numbers based on the nature of changes committed to the codebase.
Integrates status badges from shields.io to display package version and license information in the README.
Click on "Deploy 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., "@mcp-with-ssh initialize a memory bank for my web project on the remote server"
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.
A Model Context Protocol (MCP) server for managing Memory Banks, allowing AI assistants to store and retrieve information across sessions. Now with remote server support!
Memory Bank Server provides a set of tools and resources for AI assistants to interact with Memory Banks. Memory Banks are structured repositories of information that help maintain context and track progress across multiple sessions.
Related MCP server: MCP Memento
Memory Bank Management: Initialize, find, and manage Memory Banks
File Operations: Read and write files in Memory Banks
Progress Tracking: Track progress and update Memory Bank files
Decision Logging: Log important decisions with context and alternatives
Active Context Management: Maintain and update active context information
Mode Support: Detect and use .clinerules files for mode-specific behavior
UMB Command: Update Memory Bank files temporarily with the UMB command
Robust Error Handling: Gracefully handle errors and continue operation when possible
Status Prefix System: Immediate visibility into Memory Bank operational state
Remote Server Support: Store Memory Banks on a remote server using SSH
By default, Memory Bank uses a memory-bank directory in the root of your project. When you specify a project path using the --path option, the Memory Bank will be created or accessed at <project_path>/memory-bank.
You can customize the name of the Memory Bank folder using the --folder option. For example, if you set --folder custom-memory, the Memory Bank will be created or accessed at <project_path>/custom-memory.
For more details on customizing the folder name, see Custom Memory Bank Folder Name.
Remote Server Support: Store your Memory Bank on a remote server via SSH
Customizable Folder Name: You can now specify a custom folder name for the Memory Bank
Consistent Directory Structure: Memory Bank now always uses the configured folder name in the project root
Enhanced Initialization: Memory Bank now works even when .clinerules files don't exist
Better Path Handling: Improved handling of absolute and relative paths
Improved Directory Detection: Better detection of existing memory-bank directories
More Robust Error Handling: Graceful handling of errors related to .clinerules files
For more details, see Memory Bank Bug Fixes.
To install Memory Bank for Claude Desktop automatically via Smithery:
npx -y @smithery/cli install @aakarsh-sasi/memory-bank-mcp --client claude# Install from npm
npm install @aakarsh-sasi/memory-bank-mcp
# Or install globally
npm install -g @aakarsh-sasi/memory-bank-mcp
# Or run directly with npx (no installation required)
npx @aakarsh-sasi/memory-bank-mcpYou can run Memory Bank MCP directly without installation using npx:
# Run with default settings
npx @aakarsh-sasi/memory-bank-mcp
# Run with specific mode
npx @aakarsh-sasi/memory-bank-mcp --mode code
# Run with custom project path
npx @aakarsh-sasi/memory-bank-mcp --path /path/to/project
# Run with custom folder name
npx @aakarsh-sasi/memory-bank-mcp --folder custom-memory-bank
# Run with remote server
npx @aakarsh-sasi/memory-bank-mcp --remote --remote-user username --remote-host example.host.com --remote-path /home/username/memory-bank
# Show help
npx @aakarsh-sasi/memory-bank-mcp --helpFor more detailed information about using npx, see npx-usage.md.
Memory Bank MCP now supports storing your Memory Bank on a remote server via SSH. This allows you to:
Centralize your Memory Bank: Keep all your project memory in one place
Share Memory Banks: Multiple users can access the same Memory Bank
Persistent Storage: Your Memory Bank persists even if your local machine is wiped
SSH access to the remote server
SSH key authentication set up (password authentication is not supported)
Sufficient permissions to create/modify files in the specified directory
To set up SSH key authentication for the remote server:
Generate a new SSH key pair (if you don't already have one):
# Using modern Ed25519 algorithm (recommended)
ssh-keygen -t ed25519 -C "your_email@example.com"
# OR using RSA if required for compatibility
ssh-keygen -t rsa -b 4096 -C "your_email@example.com"Start the SSH agent and add your key:
# Start the agent
eval "$(ssh-agent -s)"
# Add your key
ssh-add ~/.ssh/id_ed25519 # or ~/.ssh/id_rsa if you used RSACopy your public key to the remote server:
# Easiest method (if available)
ssh-copy-id username@your-remote-host.com
# Alternative: manually copy your public key
cat ~/.ssh/id_ed25519.pub # copy the outputThen paste the key into the ~/.ssh/authorized_keys file on the remote server.
Test your connection:
ssh username@your-remote-host.comYou should be able to log in without a password.
For more detailed SSH key setup instructions, see our SSH Keys Guide.
To use remote server mode, you need to provide the following parameters:
npx @aakarsh-sasi/memory-bank-mcp --remote \
--ssh-key ~/.ssh/your_ssh_key \
--remote-user username \
--remote-host example.host.com \
--remote-path /home/username/memory-bankBy default, the SSH key is assumed to be at ~/.ssh/your_ssh_key. You can specify a different key using the --ssh-key option.
# Using with a server at example.host.com
npx @aakarsh-sasi/memory-bank-mcp --remote \
--remote-user username \
--remote-host example.host.com \
--remote-path /home/username/memory-bankCursor is an AI-powered code editor that supports the Model Context Protocol (MCP). To configure Memory Bank MCP in Cursor:
Use Memory Bank MCP with npx:
No need to install the package globally. You can use npx directly:
# Verify npx is working correctly
npx @aakarsh-sasi/memory-bank-mcp --helpOpen Cursor Settings:
Go to Settings (⚙️) > Extensions > MCP
Click on "Add MCP Server"
Configure the MCP Server:
Name: Memory Bank MCP
Command: npx
Arguments: @aakarsh-sasi/memory-bank-mcp --mode code (or other mode as needed)
For remote server:
Arguments: @aakarsh-sasi/memory-bank-mcp --mode code --remote --remote-user username --remote-host example.host.com --remote-path /home/username/memory-bank
Save and Activate:
Click "Save"
Enable the MCP server by toggling it on
Verify Connection:
Open a project in Cursor
The Memory Bank MCP should now be active and available in your AI interactions
For detailed instructions and advanced usage with Cursor, see cursor-integration.md.
Once configured, you can interact with Memory Bank MCP in Cursor through AI commands:
Initialize a Memory Bank: /mcp memory-bank-mcp initialize_memory_bank path=./memory-bank
Track Progress: /mcp memory-bank-mcp track_progress action="Feature Implementation" description="Implemented feature X"
Log Decision: /mcp memory-bank-mcp log_decision title="API Design" context="..." decision="..."
Switch Mode: /mcp memory-bank-mcp switch_mode mode=code
Memory Bank MCP supports different operational modes to optimize AI interactions for specific tasks:
Code Mode 👨💻
Focus: Code implementation and development
Usage: npx @aakarsh-sasi/memory-bank-mcp --mode code
Best for: Writing, refactoring, and optimizing code
Architect Mode 🏗️
Focus: System design and architecture
Usage: npx @aakarsh-sasi/memory-bank-mcp --mode architect
Best for: Planning project structure, designing components, and making architectural decisions
Ask Mode ❓
Focus: Answering questions and providing information
Usage: npx @aakarsh-sasi/memory-bank-mcp --mode ask
Best for: Getting explanations, clarifications, and information
Debug Mode 🐛
Focus: Troubleshooting and problem-solving
Usage: npx @aakarsh-sasi/memory-bank-mcp --mode debug
Best for: Finding and fixing bugs, analyzing issues
Test Mode ✅
Focus: Testing and quality assurance
Usage: npx @aakarsh-sasi/memory-bank-mcp --mode test
Best for: Writing tests, test-driven development
You can switch modes in several ways:
When starting the server:
npx @aakarsh-sasi/memory-bank-mcp --mode architectDuring a session:
memory-bank-mcp switch_mode mode=debugIn Cursor:
/mcp memory-bank-mcp switch_mode mode=testUsing .clinerules files:
Create a .clinerules-[mode] file in your project to automatically switch to that mode when the file is detected.
Memory Bank MCP is built on the Model Context Protocol (MCP), which enables AI assistants to interact with external tools and resources. Here's how it works:
Memory Bank: A structured repository of information stored as markdown files:
product-context.md: Overall project information and goals
active-context.md: Current state, ongoing tasks, and next steps
progress.md: History of project updates and milestones
decision-log.md: Record of important decisions with context and rationale
system-patterns.md: Architecture and code patterns used in the project
MCP Server: Provides tools and resources for AI assistants to interact with Memory Banks:
Runs as a standalone process
Communicates with AI assistants through the MCP protocol
Provides a set of tools for managing Memory Banks
Mode System: Supports different operational modes:
code: Focus on code implementation
ask: Focus on answering questions
architect: Focus on system design
debug: Focus on debugging issues
test: Focus on testing
Initialization: The AI assistant connects to the MCP server and initializes a Memory Bank
Tool Calls: The AI assistant calls tools provided by the MCP server to read/write Memory Bank files
Context Maintenance: The Memory Bank maintains context across sessions, allowing the AI to recall previous decisions and progress
Memory Banks use a standardized structure to organize information:
Product Context: Project overview, objectives, technologies, and architecture
Active Context: Current state, ongoing tasks, known issues, and next steps
Progress: Chronological record of project updates and milestones
Decision Log: Record of important decisions with context, alternatives, and consequences
System Patterns: Architecture patterns, code patterns, and documentation patterns
UMB Command: Temporarily update Memory Bank files during a session without committing changes
Mode Detection: Automatically detect and switch modes based on user input
File Migration: Tools for migrating between different file naming conventions
Language Standardization: All Memory Bank files are generated in English for consistency
This project follows Semantic Versioning and uses Conventional Commits for commit messages. The version is automatically bumped and a changelog is generated based on commit messages when changes are merged into the main branch.
Major version is bumped when there are breaking changes (commit messages with BREAKING CHANGE or !:)
Minor version is bumped when new features are added (commit messages with feat: or feat(scope):)
Patch version is bumped for all other changes (bug fixes, documentation, etc.)
For the complete history of changes, see the CHANGELOG.md file.
# Initialize a Memory Bank
memory-bank-mcp initialize_memory_bank path=./memory-bank
# Track progress
memory-bank-mcp track_progress action="Feature Implementation" description="Implemented feature X"
# Log a decision
memory-bank-mcp log_decision title="API Design" context="..." decision="..."
# Switch mode
memory-bank-mcp switch_mode mode=codeimport { MemoryBankServer } from "@aakarsh-sasi/memory-bank-mcp";
// Create a new server instance
const server = new MemoryBankServer();
// Start the server
server.run().catch(console.error);Please see CONTRIBUTING.md for details on our code of conduct and the process for submitting pull requests.
This project is licensed under the MIT License - see the LICENSE file for details.
Memory Bank MCP implements a status prefix system that provides immediate visibility into the operational state of the Memory Bank:
Every response from an AI assistant using Memory Bank MCP begins with one of these status indicators:
[MEMORY BANK: ACTIVE]: The Memory Bank is available and being used to provide context-aware responses
[MEMORY BANK: INACTIVE]: The Memory Bank is not available or not properly configured
[MEMORY BANK: UPDATING]: The Memory Bank is currently being updated (during UMB command execution)
This system ensures users always know whether the AI assistant is operating with full context awareness or limited information.
Transparency: Users always know whether the AI has access to the full project context
Troubleshooting: Makes it immediately obvious when Memory Bank is not properly configured
Context Awareness: Helps users understand why certain responses may lack historical context
For more details, see Memory Bank Status Prefix System.
Completes the Update Memory Bank (UMB) process
| 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 fails to describe what 'completing' entails—whether it's a read-only operation, a destructive update, requires specific permissions, has side effects, or what the expected outcome is. This leaves critical behavioral traits unspecified for a tool named 'complete_umb'.
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, efficient sentence with no wasted words. It's front-loaded and directly states the tool's action, making it highly concise and well-structured for its limited content.
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 complexity implied by 'complete_umb' (suggesting a multi-step process) and the lack of annotations or output schema, the description is incomplete. It doesn't explain what 'UMB' is, what 'completing' it achieves, or how it relates to sibling tools, leaving significant gaps for the agent to understand the tool's role and 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 tool has 0 parameters with 100% schema description coverage, so the schema fully documents the lack of inputs. The description doesn't need to add parameter details, and it appropriately avoids discussing nonexistent parameters, earning a baseline score of 4 for not introducing confusion.
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 'Completes the Update Memory Bank (UMB) process' is a tautology that restates the tool name 'complete_umb' with minimal elaboration. It specifies a verb ('completes') and resource ('Update Memory Bank process'), but lacks detail on what the UMB process entails or what 'completing' it actually does, making it vague and uninformative beyond the name itself.
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. With sibling tools like 'initialize_memory_bank', 'process_umb_command', and 'update_active_context', it's unclear what distinguishes 'complete_umb' from these related operations, leaving the agent without context for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Debug the current MCP configuration
| Name | Required | Description | Default |
|---|---|---|---|
| verbose | No | Whether to include detailed information |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description must disclose behavior. It only says 'Debug' without explaining what that entails—no side effects, whether it runs checks, or what output is produced. The parameter 'verbose' hints at detail but does not clarify core 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?
One concise sentence with no unnecessary words or repetition. Front-loaded and efficient.
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?
No output schema and no description of what the tool returns or its behavior. For a debug tool, agents need to know output format and potential actions—completely missing.
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 boolean parameter, so the description need not add param info. It does not add meaning beyond the schema, yielding a baseline 3.
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 'Debug the current MCP configuration,' which is a specific verb and resource. No sibling tool has a similar purpose, so it is well-distinguished.
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 vs alternatives or prerequisites. While it is a standalone debug tool, context about typical scenarios (e.g., configuration issues) is missing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Gets information about the current mode
| 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 'gets information', implying a read-only operation, but doesn't specify what information is returned (e.g., mode name, status, settings), whether it requires permissions, or if it has side effects like logging. For a tool with zero annotation coverage, this leaves significant gaps in understanding its 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 a single, efficient sentence: 'Gets information about the current mode'. It's front-loaded with the core action and resource, with no wasted words. However, it could be more structured by including key details like the type of information returned, but given its brevity, it's 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?
Given the lack of annotations and output schema, the description is incomplete for understanding the tool's functionality. It doesn't explain what 'information' is returned (e.g., a mode identifier, configuration details), how it might be used in context with sibling tools, or any behavioral traits. For a tool with no structured data to rely on, the description should provide more context to be fully helpful.
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% (as there are no parameters to describe). The description doesn't need to add parameter semantics beyond what the schema provides, so it meets the baseline expectation. No additional parameter information is required or 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 'Gets information about the current mode' is a tautology that essentially restates the tool name 'get_current_mode'. While it clarifies the verb 'gets' and resource 'current mode', it doesn't specify what type of information is retrieved or how this differs from sibling tools like 'switch_mode' or 'debug_mcp_config'. The purpose is stated but lacks specificity and 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 is provided on when to use this tool versus alternatives. With sibling tools like 'switch_mode' (which likely changes modes) and 'debug_mcp_config' (which might inspect configuration), the description doesn't indicate scenarios where retrieving current mode information is preferred or necessary. There's no mention of prerequisites, timing, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check Memory Bank status
| Name | Required | Description | Default |
|---|---|---|---|
| random_string | Yes | Dummy parameter for no-parameter tools |
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 only states the action ('check') without detailing what the check entails (e.g., read-only operation, potential side effects, error handling, or response format). For a status-checking tool with zero annotation coverage, this is a significant gap in transparency.
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 extremely concise ('Check Memory Bank status'), consisting of a single, front-loaded sentence that directly states the tool's purpose without unnecessary words. Every part of the description earns its place by conveying the core action and target efficiently.
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 complexity of a status-checking tool with no annotations and no output schema, the description is incomplete. It lacks details on what 'status' includes, how results are returned, or any behavioral context, making it inadequate for an agent to understand the tool's full scope and usage without additional inference.
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 input schema has 1 parameter with 100% description coverage, documenting it as a 'Dummy parameter for no-parameter tools'. The description does not add any parameter-specific information beyond this, which is acceptable since the schema fully covers the parameter. With 0 meaningful parameters, a baseline of 4 is appropriate as the description need not compensate.
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 'Check Memory Bank status' clearly states the action (check) and target (Memory Bank status), avoiding tautology. However, it lacks specificity about what 'status' entails (e.g., operational state, usage metrics, or configuration) and does not differentiate from siblings like 'get_current_mode' or 'debug_mcp_config', which might overlap in monitoring functions.
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. With siblings like 'get_current_mode' and 'debug_mcp_config' that could relate to system status, the description fails to indicate context, prerequisites, or exclusions, leaving the agent to infer usage based on tool names alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Initialize a Memory Bank in the specified directory
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Path where the Memory Bank will be initialized |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose side effects but only says 'Initialize a Memory Bank'. It does not mention what happens if the bank already exists, permissions needed, or any destructive potential.
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 with no wasted words. It is concise, though very brief; it could expand slightly without losing conciseness.
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 adequate. However, it lacks context about prerequisites or post-conditions, leaving some gaps for 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?
Schema coverage is 100% with a clear description for the 'path' parameter. The tool description adds no extra semantic value beyond what the schema already provides, resulting in a baseline score of 3.
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 verb 'Initialize' and resource 'Memory Bank', with the specific directory. It is specific enough to distinguish from sibling tools like 'set_memory_bank_path' which implies an existing bank, but does not explicitly state this 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?
No guidance is provided on when to use this tool versus alternatives like 'set_memory_bank_path' or what prerequisites exist. The description gives no context about appropriate scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List Memory Bank files
| Name | Required | Description | Default |
|---|---|---|---|
| random_string | Yes | Dummy parameter for no-parameter tools |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must fully disclose behavioral traits. It only states the action 'List Memory Bank files', failing to cover critical aspects such as whether this is a read-only operation, potential side effects, authentication needs, rate limits, or output format. This is inadequate for a tool with no annotation support, leaving the agent uninformed about its 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 extremely concise at three words, with no wasted text. It is front-loaded and directly states the tool's action without unnecessary elaboration, making it efficient for quick understanding. However, this conciseness comes at the cost of completeness, but it scores high on this dimension alone.
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. It does not explain what 'List' entails (e.g., format, pagination, filtering) or how it relates to sibling tools. For a tool with no structured support, more context is needed to guide the agent effectively, making this insufficient for reliable 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 input schema has 1 parameter with 100% description coverage, documenting it as a 'Dummy parameter for no-parameter tools'. The description adds no parameter information, but since the schema fully covers the single parameter and it's a dummy, this is acceptable. The baseline is 3 for high schema coverage, but the dummy nature elevates it as no meaningful parameters need explanation.
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 'List Memory Bank files' restates the tool name 'list_memory_bank_files' with minimal elaboration, making it tautological. It specifies the verb 'List' and resource 'Memory Bank files', but lacks differentiation from sibling tools like 'read_memory_bank_file' or details on scope (e.g., all files, filtered). This is a basic restatement that provides little additional insight.
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 offers no guidance on when to use this tool versus alternatives. It does not mention sibling tools such as 'read_memory_bank_file' for reading specific files or 'get_memory_bank_status' for status checks, nor does it provide context like prerequisites or exclusions. This leaves the agent without direction on appropriate usage scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Log a decision in the decision log
| Name | Required | Description | Default |
|---|---|---|---|
| alternatives | No | Alternatives considered | |
| consequences | No | Consequences of the decision | |
| context | Yes | Decision context | |
| decision | Yes | The decision made | |
| title | Yes | Decision title |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must describe behavioral traits. It fails to disclose any side effects, persistence behavior, or required state. The minimal description offers no transparency beyond the basic action.
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 extremely concise at 6 words, with no wasted content. It front-loads the core purpose. However, it is so brief that it may sacrifice clarity for brevity.
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 has 5 parameters, 3 required, and no output schema, the description is insufficiently complete. It does not explain the tool's integration, output, or any contextual details needed to use it effectively.
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 input schema covers all 5 parameters with descriptions, achieving 100% coverage. The tool description adds no additional meaning or examples beyond what the schema provides, so it meets the baseline without adding value.
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 indicates the action (log) and resource (decision/decision log), distinguishing it from sibling tools like add_progress_entry or add_session_note. However, it could be more specific about the scope and purpose of the decision log.
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 compared to alternatives, nor does it mention prerequisites, limitations, or exclusions. The agent is left to infer usage from context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Migrate Memory Bank files from camelCase to kebab-case naming convention
| Name | Required | Description | Default |
|---|---|---|---|
| random_string | Yes | Dummy parameter for no-parameter tools |
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 migration action but lacks critical details: whether this is a destructive operation (e.g., renames files in place), requires specific permissions, handles errors, or provides progress feedback. For a tool that likely modifies file names, this omission is significant.
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, efficient sentence that directly states the tool's purpose without any fluff or redundancy. It is appropriately sized and front-loaded, making it easy for an agent to parse quickly.
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, and the tool's likely complexity (migrating file names), the description is incomplete. It does not explain what the migration entails (e.g., batch processing, dry-run options), potential side effects, or return values, leaving gaps for safe and effective use by 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 input schema has 100% coverage with one parameter described as a 'Dummy parameter for no-parameter tools', indicating no meaningful parameters. The description does not add parameter details beyond this, but with zero functional parameters, the baseline is 4 as the schema adequately handles the dummy case without needing extra explanation in the description.
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 ('Migrate') and resource ('Memory Bank files'), with precise details about the naming convention change ('from camelCase to kebab-case'). It distinguishes this tool from siblings like 'list_memory_bank_files' or 'write_memory_bank_file' by focusing on a migration operation rather than listing, reading, or writing files.
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, such as whether it should be run once during setup or as needed for file consistency. It does not mention prerequisites, exclusions, or related tools, leaving the agent to infer usage context from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Processes the Update Memory Bank (UMB) command
| Name | Required | Description | Default |
|---|---|---|---|
| command | Yes | Complete UMB command |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It only states 'Processes', implying a mutation or action, but doesn't disclose behavioral traits such as side effects, permissions needed, error handling, or what 'processing' entails operationally, leaving significant gaps.
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, efficient sentence with no wasted words, making it appropriately sized. However, it's front-loaded with minimal content, which limits its helpfulness despite being 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 no annotations, no output schema, and a vague purpose, the description is incomplete. It doesn't explain what 'processing' involves, the return values, or how it fits with siblings, failing to provide enough context for 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 schema description coverage is 100%, with the parameter 'command' documented as 'Complete UMB command'. The description adds no additional meaning beyond this, so it meets the baseline of 3 where the schema does the heavy lifting without extra value from the description.
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 states the tool 'Processes the Update Memory Bank (UMB) command', which provides a basic verb+resource (process + UMB command). However, it's vague about what processing entails and doesn't differentiate from siblings like 'complete_umb' or 'update_active_context', leaving ambiguity about its specific role.
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. With siblings like 'complete_umb' and 'update_active_context' that might overlap, the description lacks context, prerequisites, or exclusions, offering no help for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read a file from the Memory Bank
| Name | Required | Description | Default |
|---|---|---|---|
| filename | Yes | Name of the file to read |
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 reads a file, implying a read-only operation, but fails to describe critical behaviors such as error handling (e.g., if the file doesn't exist), return format (e.g., text content), permissions needed, or any side effects. This leaves significant gaps for agent understanding.
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 with zero wasted words, making it highly concise and front-loaded. It directly communicates the core purpose without unnecessary elaboration, earning full marks for efficiency.
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 a tool that reads files. It does not explain what is returned (e.g., file content as text), error conditions, or how it interacts with the Memory Bank system. For a read operation with no structured output documentation, more context is needed to guide the agent effectively.
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 input schema has 100% description coverage, with the 'filename' parameter fully documented in the schema. The description does not add any semantic details beyond what the schema provides (e.g., file naming conventions, supported extensions, or path structure). 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 action ('Read') and resource ('a file from the Memory Bank'), making the purpose immediately understandable. However, it does not explicitly differentiate from sibling tools like 'list_memory_bank_files' or 'write_memory_bank_file', which would require mentioning it retrieves file content rather than metadata or performs a read-only operation versus writing.
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 does not mention prerequisites (e.g., files must exist), exclusions, or comparisons to siblings like 'list_memory_bank_files' for browsing or 'write_memory_bank_file' for modifications, leaving usage context unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Set a custom path for the Memory Bank
| Name | Required | Description | Default |
|---|---|---|---|
| path | No | Custom path for the Memory Bank. If not provided, the current directory will be used. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description must disclose all behavioral traits. It only states 'Set' without indicating persistence, scope (global vs. session), side effects (e.g., overriding existing path), or any required prior steps. This is insufficient for an AI agent.
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 extremely short (one sentence). While concise, it lacks structure or additional detail that would improve usability. It is not wasteful but is borderline under-specified.
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 simplicity (1 optional param, no output schema), the description still fails to cover behavioral aspects like what happens if the path is invalid, whether it persists, or how it interacts with other memory bank operations. The context is incomplete for agent decision-making.
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 input schema has 100% coverage (one parameter documented). The description adds the word 'custom' but otherwise does not enhance understanding beyond the schema's description. Baseline 3 is appropriate.
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 ('Set') and resource ('custom path for the Memory Bank'). It distinguishes from siblings like 'initialize_memory_bank' and 'get_memory_bank_status', though it could be more precise about what 'path' entails.
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, such as 'initialize_memory_bank' for initial setup or 'select_store' for store selection. It implies it is used to change the path but does not explain prerequisites or context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Switches to a specific mode
| Name | Required | Description | Default |
|---|---|---|---|
| mode | Yes | Name of the mode to switch to (architect, ask, code, debug, test) |
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 but offers almost none. 'Switches to a specific mode' implies a state change, but it doesn't describe what effects this has (e.g., does it alter system behavior, require permissions, have side effects like resetting other states, or provide feedback?). It lacks details on success/failure conditions, response format, or any behavioral traits, making it inadequate for a mutation 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 extremely concise with just one sentence, 'Switches to a specific mode', which is front-loaded and wastes no words. However, this brevity borders on under-specification, as it lacks necessary detail for a tool that likely performs a state mutation. While efficient, it could benefit from additional context to earn a higher score.
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 complexity of a mode-switching tool (likely a state mutation with no annotations and no output schema), the description is severely incomplete. It doesn't explain what 'mode' entails, what happens after switching, potential errors, or how it interacts with sibling tools. For a tool that may change system behavior, this minimal description fails to provide the context needed for safe and 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 no parameter semantics beyond what the input schema provides. The schema has 100% description coverage, with the 'mode' parameter clearly documented as 'Name of the mode to switch to (architect, ask, code, debug, test)'. Since the schema does the heavy lifting, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't detract from the schema's completeness.
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 'Switches to a specific mode' is a tautology that essentially restates the tool name 'switch_mode' without adding meaningful specificity. It mentions the action 'switches' and the resource 'mode', but fails to clarify what 'mode' means in this context or what the tool actually accomplishes beyond the literal interpretation of its name. Compared to siblings like 'get_current_mode' or 'update_active_context', it doesn't distinguish its purpose clearly.
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 any prerequisites, context for switching modes, or refer to sibling tools like 'get_current_mode' (which might be used before switching) or 'update_active_context' (which might be related). There's no indication of when this tool is appropriate or what scenarios it's designed for, leaving the agent with no usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Track progress and update Memory Bank files
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Action performed (e.g., 'Implemented feature', 'Fixed bug') | |
| description | Yes | Detailed description of the progress | |
| updateActiveContext | No | Whether to update the active context file |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must fully disclose behavior. It mentions updating Memory Bank files but does not specify which files, the effect of updateActiveContext, or whether the operation is destructive.
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 very concise (6 words), but it sacrifices clarity for brevity. It is not front-loaded with key information.
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 3 parameters, the description is insufficient. It does not provide enough context for an agent to understand the tool's role in the memory bank workflow.
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 baseline is 3. The description adds no extra meaning beyond what the schema already provides.
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 'Track progress and update Memory Bank files' provides a general purpose but lacks specificity. It does not clearly differentiate from sibling tools like add_progress_entry or update_tasks.
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 vs alternatives such as add_progress_entry or add_session_note. The description does not mention 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 the active context file
| Name | Required | Description | Default |
|---|---|---|---|
| issues | No | List of known issues | |
| nextSteps | No | List of next steps | |
| tasks | No | List of ongoing tasks |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must convey behavioral traits. It fails to disclose whether updates are destructive, append vs. replace, or require any prerequisites. The single sentence offers no behavioral insight beyond the action.
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?
At only 5 words, the description is extremely terse. While concise, it omits necessary details, making it under-specified rather than efficiently structured.
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 has 3 optional parameters and no output schema, the description should explain how parameters relate, default behavior, and the concept of 'active context'. It provides none of this, leaving the agent underinformed.
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?
All three parameters (tasks, issues, nextSteps) have descriptions in the schema (100% coverage). The description adds no additional meaning beyond what the schema already provides, so baseline 3 is appropriate.
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 states the tool updates the 'active context file', providing a verb and resource. However, it lacks specificity about what fields are updated (tasks, issues, nextSteps) and does not differentiate from sibling tools like 'update_tasks', which may have overlapping 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?
No guidance is provided on when to use this tool versus alternatives (e.g., update_tasks, add_progress_entry). The description offers no context for appropriate invocation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Write to a Memory Bank file
| Name | Required | Description | Default |
|---|---|---|---|
| content | Yes | Content to write to the file | |
| filename | Yes | Name of the file to write |
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 states the write operation but doesn't cover critical aspects like permissions required, whether it overwrites existing files, error handling, or side effects. This is inadequate for a mutation 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, efficient sentence with zero wasted words. It's appropriately sized and front-loaded, directly stating the tool's purpose without 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 this is a write operation with no annotations and no output schema, the description is insufficient. It lacks details on behavioral traits, error conditions, or what happens on success/failure, leaving significant gaps for a mutation tool in a context with multiple sibling tools.
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 both parameters ('filename' and 'content'). The description adds no additional meaning beyond what the schema provides, such as file format expectations or content constraints, meeting the baseline 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 action ('Write') and target resource ('Memory Bank file'), providing a specific verb+resource combination. However, it doesn't differentiate from sibling tools like 'read_memory_bank_file' or 'list_memory_bank_files' beyond the basic operation type, missing explicit 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. There are no mentions of prerequisites, when-not-to-use scenarios, or comparisons with sibling tools like 'update_active_context' or 'log_decision' that might handle related operations.
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.
v1.0.0complete_umbdebug_mcp_configget_current_modeget_memory_bank_statusinitialize_memory_banklist_memory_bank_fileslog_decisionmigrate_file_namingprocess_umb_commandread_memory_bank_fileset_memory_bank_pathswitch_modetrack_progressupdate_active_contextwrite_memory_bank_fileScored across 15 tools
Most tools have distinct purposes, but there is notable overlap between 'complete_umb' and 'process_umb_command' which both handle UMB processes, and 'track_progress' and 'update_active_context' could be confused for similar context management tasks. Descriptions help clarify, but some ambiguity remains.
Tool names follow a consistent verb_noun pattern throughout, such as 'initialize_memory_bank' and 'read_memory_bank_file', with minor deviations like 'debug_mcp_config' using 'debug' instead of a more standard verb. Overall, the naming is predictable and readable.
With 15 tools, the count is well-scoped for managing a Memory Bank system, covering initialization, reading/writing files, status checks, mode switching, and debugging. Each tool appears to serve a specific function without unnecessary bloat.
The tool set provides comprehensive CRUD-like coverage for Memory Bank operations, including initialization, file management, status tracking, and mode control. Minor gaps may exist, such as lacking direct tools for deleting files or advanced configuration management, but core workflows are well-supported.
Personal knowledge base MCP server with semantic search, auto-categorization, metadata extraction
Shared memory for coding agents. Stop re-explaining your codebase every session.
One memory, every AI. A shared, user-owned markdown memory your AI clients read and write over MCP.
Personal knowledge MCP: capture bookmarks, notes & todos by chat; archive pages; search memory.