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 "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., "@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 are provided, so the description carries the full burden of behavioral disclosure. 'Debug' implies a read-only or diagnostic operation, but the description doesn't clarify if it's safe, what it outputs, or if it has side effects like logging or configuration changes. For a 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 a single, efficient sentence with no wasted words. It's front-loaded and directly states the tool's purpose, making it easy to parse. Every word earns its place, achieving optimal conciseness for such a simple tool.
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 doesn't explain what debugging outputs (e.g., configuration details, errors), how it behaves, or its role among sibling tools. For a tool in a complex server with many siblings, this minimal description leaves critical context 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?
The input schema has 1 parameter with 100% description coverage, so the schema fully documents the 'verbose' parameter. The description adds no parameter information beyond the schema, but with high schema coverage and only one optional parameter, the baseline is high. A score of 4 reflects that the schema handles parameter semantics adequately, though the description doesn't enhance it.
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's purpose ('Debug the current MCP configuration'), which is clear but vague. It specifies the verb ('Debug') and resource ('MCP configuration'), but doesn't explain what debugging entails or how it differs from sibling tools like 'get_current_mode' or 'switch_mode'. The purpose is understandable but lacks specificity.
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, or exclusions, nor does it reference sibling tools. Without usage guidelines, an agent must infer when debugging is appropriate, which could lead to misuse.
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 provided, the description carries the full burden of behavioral disclosure. It states the action ('Initialize') but lacks details on what initialization entails (e.g., creates files, sets up structures, permissions required, side effects, or error conditions). 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 that directly states the tool's purpose without unnecessary words. It is front-loaded and wastes no space, making it easy 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 tool's complexity (initialization implies mutation), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what 'Initialize a Memory Bank' means in practice, potential outcomes, or error handling, leaving significant gaps for an agent to understand the tool's behavior and usage.
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 semantic context by implying the 'path' parameter specifies where initialization occurs, but the input schema already provides 100% coverage with a clear description ('Path where the Memory Bank will be initialized'). No additional parameter details are given, so it meets 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 ('Initialize') and resource ('Memory Bank') with the location constraint ('in the specified directory'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'set_memory_bank_path' or 'complete_umb', which might have overlapping or related functionality, preventing 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 prerequisites (e.g., if the directory must exist), exclusions, or compare to siblings like 'set_memory_bank_path' or 'complete_umb', leaving the agent with insufficient context for optimal tool selection.
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?
With no annotations provided, the description carries the full burden of behavioral disclosure but fails to do so. It states the action ('Log a decision') but doesn't reveal critical traits like whether this is a write operation, if it requires specific permissions, what the log format is, or if there are side effects (e.g., persistence, rate limits). This is inadequate for a tool that likely mutates state.
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—a single sentence with zero waste. It is front-loaded and appropriately sized for its minimal content, though this conciseness contributes to its overall inadequacy in other dimensions.
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 (5 parameters, likely a write operation) and lack of annotations or output schema, the description is incomplete. It doesn't explain what 'logging' entails (e.g., storage, retrieval), the return values, or behavioral context, leaving significant gaps for the agent to infer usage.
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 all parameters clearly documented (e.g., 'Alternatives considered', 'Decision title'). The description adds no additional meaning beyond the schema, so it meets the baseline of 3 where the schema does the heavy lifting, but doesn't compensate or enhance parameter understanding.
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 'Log a decision in the decision log' is tautological, essentially restating the tool name 'log_decision' without adding meaningful specificity. It lacks a clear verb+resource distinction and doesn't differentiate from sibling tools, which are unrelated to decision logging (e.g., memory bank operations, mode switching).
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 or in what context it should be invoked. The description offers no prerequisites, exclusions, or comparisons to other tools, leaving 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.
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?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool sets a path but does not explain what happens after setting (e.g., if it persists across sessions, requires restart, or affects other operations). For a mutation tool with zero annotation coverage, this is a significant gap in transparency regarding side effects or requirements.
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, direct sentence that states the tool's purpose without any fluff or redundancy. It is front-loaded and efficiently communicates the core action, making it highly concise and well-structured for quick understanding.
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 as a mutation operation with no annotations and no output schema, the description is incomplete. It does not cover behavioral aspects like persistence, error handling, or how it interacts with sibling tools (e.g., 'initialize_memory_bank'). For a tool that modifies system state, more context is needed to ensure safe and correct usage 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 schema description coverage is 100%, with the parameter 'path' clearly documented in the input schema as a string for a custom path, defaulting to the current directory if not provided. The description adds no additional meaning beyond what the schema provides, so it meets the baseline score of 3 for adequate but not enhanced parameter semantics.
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 the resource ('custom path for the Memory Bank'), making the purpose immediately understandable. However, it does not differentiate this tool from potential siblings like 'initialize_memory_bank' or 'update_active_context', which might involve related path or configuration operations, so it falls short of 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 does not mention prerequisites, such as whether the Memory Bank must be initialized first, or compare it to sibling tools like 'initialize_memory_bank' or 'switch_mode' that might affect paths or settings. This lack of context leaves the agent guessing about appropriate usage scenarios.
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?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool updates Memory Bank files, implying a write/mutation operation, but doesn't specify what 'track progress' entails (e.g., creates new entries, appends to files, modifies existing data). It also lacks details on permissions, side effects, error handling, or response format, leaving significant gaps for a tool that modifies data.
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 front-loads the core purpose ('Track progress and update Memory Bank files'). It avoids redundancy and wastes no words, making it easy to parse quickly. However, it could be slightly more structured by explicitly separating the tracking and updating aspects for clarity.
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 progress-tracking tool with no annotations and no output schema, the description is incomplete. It doesn't explain what 'progress' means in this context, how updates affect Memory Bank files, what the tool returns, or any behavioral nuances. For a mutation tool with 3 parameters, this leaves too much unspecified for reliable agent 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?
Schema description coverage is 100%, so the schema already documents all parameters (action, description, updateActiveContext) with clear descriptions. The tool description adds no additional meaning beyond what's in the schema, such as explaining how parameters interact or their impact on Memory Bank files. With high schema coverage, the baseline is 3, as the description doesn't compensate but also doesn't detract.
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' states the general purpose but lacks specificity. It mentions tracking progress and updating files, but doesn't clarify what 'track progress' means operationally (e.g., logging, recording, documenting) or what specific Memory Bank files are involved. It distinguishes somewhat from siblings like 'log_decision' or 'write_memory_bank_file' by implying progress tracking, but the distinction is vague.
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 prerequisites (e.g., requires an initialized memory bank), exclusions, or comparisons to siblings like 'log_decision', 'update_active_context', or 'write_memory_bank_file'. Without such context, an agent must infer usage from the tool name and parameters alone.
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 provided, the description carries full burden but only states the action ('update') without disclosing behavioral traits. It doesn't specify whether this is a mutation, what permissions are needed, if changes are reversible, or any side effects (e.g., overwriting existing data), which is inadequate for a tool that likely modifies a file.
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 concise. However, it lacks front-loading of critical details (e.g., purpose differentiation), slightly reducing its effectiveness despite the 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 complexity of updating a context file with no annotations or output schema, the description is incomplete. It doesn't explain what the active context file is, how updates are applied (e.g., append vs. replace), or what the tool returns, leaving significant gaps for the agent to infer from sibling tools or trial-and-error.
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, clearly documenting parameters (issues, nextSteps, tasks) as arrays of strings. The description adds no meaning beyond this, but the schema provides sufficient detail, so the baseline score of 3 is appropriate as it doesn't compensate for gaps but doesn't need to.
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 'Update the active context file' restates the tool name with minimal elaboration, making it tautological. While it specifies the resource ('active context file'), it doesn't clarify what 'update' entails or distinguish this from sibling tools like 'write_memory_bank_file' or 'log_decision', which may involve similar file operations.
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. It doesn't mention prerequisites, context (e.g., when the active context file is relevant), or exclusions, leaving the agent to guess based on sibling tool names like 'write_memory_bank_file' or 'track_progress' without explicit direction.
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.
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.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
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.
Persistent cross-session memory shared by Codex, Claude Code, ChatGPT, and other AI agents.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/aakarsh-sasi/memory-bank-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server