Un servidor de Protocolo de Contexto de Modelo (MCP) para la gestión de bancos de memoria, que permite a los asistentes de IA almacenar y recuperar información entre sesiones. ¡Ahora con compatibilidad con servidores remotos!
El Servidor de Bancos de Memoria proporciona un conjunto de herramientas y recursos para que los asistentes de IA interactúen con los Bancos de Memoria. Estos son repositorios estructurados de información que ayudan a mantener el contexto y a monitorizar el progreso en múltiples sesiones.
Related MCP server: MCP Memento
Gestión del banco de memoria : inicializar, buscar y gestionar bancos de memoria
Operaciones de archivos : leer y escribir archivos en bancos de memoria
Seguimiento del progreso : realice un seguimiento del progreso y actualice los archivos del banco de memoria
Registro de decisiones : registre decisiones importantes con contexto y alternativas
Gestión del contexto activo : mantener y actualizar la información del contexto activo
Compatibilidad de modo : Detecta y utiliza archivos .clinerules para el comportamiento específico del modo
Comando UMB : Actualice temporalmente los archivos del banco de memoria con el comando UMB
Manejo robusto de errores : gestione los errores con elegancia y continúe la operación cuando sea posible
Sistema de prefijo de estado : visibilidad inmediata del estado operativo del banco de memoria
Compatibilidad con servidor remoto : almacene bancos de memoria en un servidor remoto mediante SSH
De forma predeterminada, el Banco de Memoria utiliza un directorio de memory-bank en la raíz del proyecto. Al especificar una ruta de proyecto con la opción --path , el Banco de Memoria se creará o accederá a él en <project_path>/memory-bank .
Puede personalizar el nombre de la carpeta del Banco de Memoria con la opción --folder . Por ejemplo, si define --folder custom-memory , el Banco de Memoria se creará o accederá a él en <project_path>/custom-memory .
Para obtener más detalles sobre cómo personalizar el nombre de la carpeta, consulte Nombre de carpeta del banco de memoria personalizado .
Soporte de servidor remoto : almacene su banco de memoria en un servidor remoto a través de SSH
Nombre de carpeta personalizable : ahora puede especificar un nombre de carpeta personalizado para el banco de memoria
Estructura de directorio consistente : Memory Bank ahora siempre usa el nombre de carpeta configurado en la raíz del proyecto
Inicialización mejorada : el banco de memoria ahora funciona incluso cuando no existen archivos .clinerules
Mejor manejo de rutas : manejo mejorado de rutas absolutas y relativas
Detección de directorios mejorada : mejor detección de directorios existentes en el banco de memoria
Manejo de errores más robusto : manejo elegante de errores relacionados con archivos .clinerules
Para obtener más detalles, consulte Corrección de errores del banco de memoria .
# 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-mcpPuede ejecutar Memory Bank MCP directamente sin instalación usando 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 --helpPara obtener información más detallada sobre el uso de npx, consulte npx-usage.md .
Memory Bank MCP ahora permite almacenar su Memory Bank en un servidor remoto mediante SSH. Esto le permite:
Centraliza tu banco de memoria : mantén toda la memoria de tus proyectos en un solo lugar
Compartir bancos de memoria : varios usuarios pueden acceder al mismo banco de memoria
Almacenamiento persistente : su banco de memoria persiste incluso si se borra su máquina local
Acceso SSH al servidor remoto
Configuración de autenticación de clave SSH (no se admite la autenticación con contraseña)
Permisos suficientes para crear/modificar archivos en el directorio especificado
Para configurar la autenticación de clave SSH para el servidor remoto:
Genere un nuevo par de claves SSH (si aún no tiene uno):
# 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"Inicie el agente SSH y agregue su clave :
# Start the agent
eval "$(ssh-agent -s)"
# Add your key
ssh-add ~/.ssh/id_ed25519 # or ~/.ssh/id_rsa if you used RSACopie su clave pública al servidor remoto :
# 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 outputLuego pegue la clave en el archivo ~/.ssh/authorized_keys en el servidor remoto.
Pruebe su conexión :
ssh username@your-remote-host.comDebería poder iniciar sesión sin una contraseña.
Para obtener instrucciones de configuración de claves SSH más detalladas, consulte nuestra Guía de claves SSH .
Para utilizar el modo de servidor remoto, debe proporcionar los siguientes parámetros:
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-bankDe forma predeterminada, se asume que la clave SSH se encuentra en ~/.ssh/your_ssh_key . Puede especificar una clave diferente con la opción --ssh-key .
# 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 es un editor de código basado en IA compatible con el Protocolo de Contexto de Modelo (MCP). Para configurar el MCP del Banco de Memoria en Cursor:
Utilice el banco de memoria MCP con npx :
No es necesario instalar el paquete globalmente. Puedes usar npx directamente:
# Verify npx is working correctly
npx @aakarsh-sasi/memory-bank-mcp --helpAbrir configuración del cursor :
Vaya a Configuración (⚙️) > Extensiones > MCP
Haga clic en "Agregar servidor MCP"
Configurar el servidor MCP :
Nombre : Banco de memoria MCP
Comando : npx
Argumentos : @aakarsh-sasi/memory-bank-mcp --mode code (u otro modo según sea necesario)
Para servidor remoto:
Argumentos : @aakarsh-sasi/memory-bank-mcp --mode code --remote --remote-user username --remote-host example.host.com --remote-path /home/username/memory-bank
Guardar y activar :
Haga clic en "Guardar"
Habilite el servidor MCP activándolo
Verificar conexión :
Abrir un proyecto en Cursor
El MCP del Banco de Memoria ahora debería estar activo y disponible en tus interacciones con IA
Para obtener instrucciones detalladas y uso avanzado con Cursor, consulte cursor-integration.md .
Una vez configurado, puedes interactuar con Memory Bank MCP en Cursor a través de comandos AI:
Inicializar un banco de memoria : /mcp memory-bank-mcp initialize_memory_bank path=./memory-bank
Progreso de seguimiento : /mcp memory-bank-mcp track_progress action="Feature Implementation" description="Implemented feature X"
Decisión de registro : /mcp memory-bank-mcp log_decision title="API Design" context="..." decision="..."
Modo de conmutación : /mcp memory-bank-mcp switch_mode mode=code
Memory Bank MCP admite diferentes modos operativos para optimizar las interacciones de IA para tareas específicas:
Modo Código 👨💻
Enfoque: Implementación y desarrollo de código
Uso: npx @aakarsh-sasi/memory-bank-mcp --mode code
Ideal para: escribir, refactorizar y optimizar código.
Modo Arquitecto 🏗️
Enfoque: Diseño y arquitectura del sistema
Uso: npx @aakarsh-sasi/memory-bank-mcp --mode architect
Ideal para: planificar la estructura del proyecto, diseñar componentes y tomar decisiones arquitectónicas.
Modo Preguntar ❓
Enfoque: Responder preguntas y proporcionar información.
Uso: npx @aakarsh-sasi/memory-bank-mcp --mode ask
Ideal para: Obtener explicaciones, aclaraciones e información.
Modo de depuración 🐛
Enfoque: Solución de problemas y resolución de problemas
Uso: npx @aakarsh-sasi/memory-bank-mcp --mode debug
Ideal para: encontrar y corregir errores, analizar problemas
Modo de prueba ✅
Enfoque: Pruebas y garantía de calidad
Uso: npx @aakarsh-sasi/memory-bank-mcp --mode test
Ideal para: escribir pruebas y desarrollo basado en pruebas.
Puedes cambiar de modo de varias maneras:
Al iniciar el servidor :
npx @aakarsh-sasi/memory-bank-mcp --mode architectDurante una sesión :
memory-bank-mcp switch_mode mode=debugEn el cursor :
/mcp memory-bank-mcp switch_mode mode=testUso de archivos .clinerules : cree un archivo .clinerules-[mode] en su proyecto para cambiar automáticamente a ese modo cuando se detecte el archivo.
Memory Bank MCP se basa en el Protocolo de Contexto de Modelo (MCP), que permite a los asistentes de IA interactuar con herramientas y recursos externos. Así funciona:
Banco de memoria : un repositorio estructurado de información almacenada como archivos Markdown:
product-context.md : Información general y objetivos del proyecto
active-context.md : Estado actual, tareas en curso y próximos pasos
progress.md : Historial de actualizaciones e hitos del proyecto
decision-log.md : Registro de decisiones importantes con contexto y justificación
system-patterns.md : Arquitectura y patrones de código utilizados en el proyecto
Servidor MCP : proporciona herramientas y recursos para que los asistentes de IA interactúen con los bancos de memoria:
Se ejecuta como un proceso independiente
Se comunica con asistentes de IA a través del protocolo MCP
Proporciona un conjunto de herramientas para gestionar bancos de memoria.
Sistema de modos : admite diferentes modos operativos:
code : Centrarse en la implementación del código
ask : centrarse en responder preguntas
architect : Enfoque en el diseño del sistema
debug : centrarse en los problemas de depuración
test : centrarse en las pruebas
Inicialización : El asistente de IA se conecta al servidor MCP e inicializa un banco de memoria
Llamadas de herramientas : el asistente de IA llama a las herramientas proporcionadas por el servidor MCP para leer/escribir archivos del banco de memoria
Mantenimiento del contexto : el banco de memoria mantiene el contexto entre sesiones, lo que permite que la IA recuerde decisiones y avances anteriores.
Los bancos de memoria utilizan una estructura estandarizada para organizar la información:
Contexto del producto : descripción general del proyecto, objetivos, tecnologías y arquitectura
Contexto activo : estado actual, tareas en curso, problemas conocidos y próximos pasos
Progreso : Registro cronológico de actualizaciones e hitos del proyecto
Registro de decisiones : Registro de decisiones importantes con contexto, alternativas y consecuencias.
Patrones del sistema : patrones de arquitectura, patrones de código y patrones de documentación
Comando UMB : Actualiza temporalmente los archivos del banco de memoria durante una sesión sin confirmar los cambios
Detección de modo : detecta y cambia automáticamente los modos según la entrada del usuario
Migración de archivos : herramientas para migrar entre diferentes convenciones de nombres de archivos
Estandarización del idioma : todos los archivos del banco de memoria se generan en inglés para mantener la coherencia.
Este proyecto sigue el control de versiones semántico y utiliza confirmaciones convencionales para los mensajes de confirmación. La versión se actualiza automáticamente y se genera un registro de cambios basado en los mensajes de confirmación cuando los cambios se fusionan en la rama principal.
La versión principal se actualiza cuando hay cambios importantes (mensajes de confirmación con BREAKING CHANGE o !: :)
La versión menor se actualiza cuando se agregan nuevas funciones (mensajes de confirmación con feat: o feat(scope): )
La versión del parche se actualiza con todos los demás cambios (corrección de errores, documentación, etc.)
Para ver el historial completo de cambios, consulte el archivo CHANGELOG.md .
# 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);Consulte CONTRIBUTING.md para obtener detalles sobre nuestro código de conducta y el proceso para enviar solicitudes de extracción.
Este proyecto está licenciado bajo la licencia MIT: consulte el archivo de LICENCIA para obtener más detalles.
El Banco de Memoria MCP implementa un sistema de prefijo de estado que proporciona visibilidad inmediata del estado operativo del Banco de Memoria:
Cada respuesta de un asistente de IA que utiliza Memory Bank MCP comienza con uno de estos indicadores de estado:
[MEMORY BANK: ACTIVE] : El banco de memoria está disponible y se utiliza para proporcionar respuestas sensibles al contexto.
[MEMORY BANK: INACTIVE] : El banco de memoria no está disponible o no está configurado correctamente
[MEMORY BANK: UPDATING] : El banco de memoria se está actualizando actualmente (durante la ejecución del comando UMB)
Este sistema garantiza que los usuarios siempre sepan si el asistente de IA está operando con conocimiento total del contexto o con información limitada.
Transparencia : los usuarios siempre saben si la IA tiene acceso al contexto completo del proyecto.
Solución de problemas : hace que sea inmediatamente evidente cuando el banco de memoria no está configurado correctamente
Conciencia del contexto : ayuda a los usuarios a comprender por qué ciertas respuestas pueden carecer de contexto histórico.
Para obtener más detalles, consulte Sistema de prefijo de estado del banco de memoria .
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.
Persistent cross-session memory shared by Codex, Claude Code, ChatGPT, and other AI agents.