What can you do with this server?

Mode Manager MCP provides a comprehensive system for managing AI memory, custom instructions, and chat modes to enhance VS Code Copilot's contextual understanding and workflow. Key capabilities: * AI Memory Management: Store and retrieve personal, team, and language-specific facts and preferences for future conversations * Chat Mode Control: Create, update, delete, list, and manage .chatmode.md files to define specific behaviors like 'Beast Mode' or 'Architect Mode' * Instruction Handling: Create, update, delete, list, and retrieve .instructions.md files that serve as foundational context for Copilot * Library Integration: Browse, refresh, and install chat modes and instructions from the curated Mode Manager MCP Library * Directory Access: Get the VS Code prompts directory path and list all stored configurations * Dynamic Customization: Easily evolve prompts and instructions as your needs change

Which integrations are available for this server?

Provides persistent memory functionality for GitHub Copilot in VS Code, allowing Copilot to remember user preferences, coding styles, and contextual information across all conversations and sessions. Uses pipx to install and run the mode-manager-mcp package, enabling easy installation and execution without affecting system dependencies. Mentioned as an example of a testing framework that can be remembered in user preferences, but not as a direct integration of the MCP server. Built on Python 3.10+, leveraging Python's capabilities for managing VS Code prompt ecosystem and implementing the persistent memory functionality.

How do I use Mode Manager MCP?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Mode Manager MCP remember I prefer using TypeScript with strict mode enabled for all new projects" 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.

Mode Manager MCP

by NiclasOlofsson

Overview Schema Source Related Servers Discussions Admin

Python

Local

Meet #remember -- Real Memory for You, Your Team, and Your AI

Install in VS Code Install in VS Code Insiders      License: MIT Python 3.8+

Mode Manager MCP is an AI-powered memory and context system for developers and teams. It lets you and your team “remember” important facts, preferences, and best practices—so your AI assistant always has the right context, and your team’s knowledge is never lost.

With Mode Manager MCP, you can:

Instantly store and retrieve personal, team, and language-specific knowledge.
Share onboarding notes, coding conventions, and project wisdom—right where you work.
Make your AI assistant smarter, more helpful, and always in sync with your workflow.

Why “Remember”? (Features & Benefits)

Personal AI Memory: Instantly store preferences, facts, and reminders for yourself—your AI assistant will always know your context.
Workspace (Team) Memory: Share best practices, onboarding notes, and team knowledge directly in the repo. New team members ramp up faster, and everyone stays on the same page.
Language-Specific Memory: Save and retrieve language-specific tips and conventions. Your assistant adapts to each language’s best practices automatically.
Natural Language Simplicity: Just say “remember…”—no config files, no YAML, no technical hurdles.
Smarter Coding, Fewer Repeated Questions: Your team’s memory grows over time, reducing repeated questions and ensuring consistent practices.- AI-Powered Memory Optimization: Automatically consolidate and organize your memories to keep them clean and efficient.

 
Before this tool
"Hey Copilot, write me a Python function..."
Copilot: Gives generic Python code
After using remember
You: "Remember I'm a senior data architect at Oatly, prefer type hints, and use Black formatting"
Next conversation: "Write me a Python function..."
Copilot: Generates perfectly styled code with type hints, following your exact preferences
 

Ready to have Copilot that actually remembers you? Get started now!

Related MCP server: repo-memory-mcp

Real-World Examples: Just Say It!

You don’t need special syntax—just talk to Copilot naturally. Mode Manager MCP is extremely relaxed about how you phrase things. If it sounds like something you want remembered, it will be!

 
Personal memory
You: I like detailed docstrings and use pytest for testing. (Copilot, keep that in mind.)
Team memory
You: We alw ays use the Oatly data pipeline template and follow our naming conventions. (Let’s make sure everyone remembers that.)
Language-specific memory You: For Python, use type hints and Black formatting. In C#, always use nullable reference types.
 

Get It Running (2 Minutes)

If you don't have Python installed, get it at python.org/downloads - you'll need Python 3.10 or higher.

Don't have uv yet? Install it with: pip install uv or see docs.astral.sh/uv

Option 1: One-Click Install (Easiest)

Click the badge for your VS Code version:

Install in VS Code Install in VS Code Insiders

That's it! The server will automatically start when you open VS Code.

Option 2: Manual Configuration

Add this to your .vscode/mcp.json or global mcp.json file:

{
  "servers": {
    "mode-manager": {
      "command": "uvx",
      "args": ["mode-manager-mcp"]
    }
  }
}

Or if you prefer pipx:

{
  "servers": {
    "mode-manager": {
      "command": "pipx",
      "args": ["run", "mode-manager-mcp"]
    }
  }
}

Option 3: Development / Testing (Latest from GitHub)

For the impatient who want the latest features immediately:

With uvx:

{
  "servers": {
    "mode-manager": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/NiclasOlofsson/mode-manager-mcp.git",
        "mode-manager-mcp"
      ]
    }
  }
}

With pipx:

{
  "servers": {
    "mode-manager": {
      "command": "pipx",
      "args": [
        "run",
        "--no-cache",
        "--spec",
        "git+https://github.com/NiclasOlofsson/mode-manager-mcp.git",
        "mode-manager-mcp"
      ]
    }
  }
}

This downloads and installs directly from GitHub every time - always bleeding edge!

Bonus: Interactive Onboarding

As a convenience, you can run the following prompt in VS Code to get started:

 
You: /mcp.mode-manager.onboarding
 

This will guide you through the onboarding process, set up your persistent memory, and ensure Copilot knows your preferences from the start.

For Development / Testing Latest from GitHub

To run the latest code directly from GitHub:

{
  "servers": {
    "mode-manager": {
      "command": "uv",
      "args": [
        "run",
        "--with",
        "git+https://github.com/NiclasOlofsson/mode-manager-mcp.git",
        "mode-manager-mcp"
      ],
      "env": {
        "_RESTART": "1"
      }
    }
  }
}

Under the Hood: How Memory Magic Happens

Mode Manager MCP is designed to make memory persistent, context-aware, and easy to manage—without you having to think about the details. Here’s how it works under the hood:

Memory Scopes

Personal Memory:
Stored in a user-specific file (memory.instructions.md) in your VS Code prompts directory. This is your private memory—preferences, habits, and facts that follow you across all projects.
Workspace (Team) Memory:
Stored in a workspace-level file (also memory.instructions.md, but in the workspace’s .github/instructions directory). This is shared with everyone working in the same repo, so team conventions and onboarding notes are always available.
Language-Specific Memory:
Stored in files like memory-python.instructions.md, memory-csharp.instructions.md, etc. These are automatically loaded when you’re working in a particular language, so language tips and conventions are always at hand.

How Memory is Stored

All memory is saved as Markdown files with a YAML frontmatter header, making it both human- and machine-readable. Each entry is timestamped and neatly organized, so you can always see when and what was remembered. You never have to manage these files yourself—Mode Manager MCP automatically creates and updates them as you add new memories.

How Memory is Loaded

Here’s the magic: Mode Manager MCP writes and manages all your memory files, but it’s actually the new VS Code Copilot Chat that automatically loads them—every single turn. This deep integration means that, every time you send a message or ask Copilot for help, your user, workspace, and language memories are instantly available to the AI.

Language-specific memory is even smarter: it’s tied to file types using the applyTo property in the YAML frontmatter (for example, **/*.py for Python or **/*.cs for C#). This means you get the right tips, conventions, and reminders only when you’re working in the relevant language or file type—no clutter, just the context you need, exactly when you need it.

You never have to worry about context being lost between messages or sessions; your memory is always active and available. We’re simply leveraging this new, amazing VS Code feature to make your Copilot (and your team) smarter than ever.

No Special Syntax Needed

There’s no need to remember special commands or keywords—just talk naturally. Mode Manager MCP is flexible and understands a wide range of phrasing. You don’t have to say “workspace” to store team memory; it recognizes common alternatives like “project,” “repo,” or even just describing something as a team convention. Whether you’re making a personal note, a team guideline, or a language-specific tip, just say it in your own words—Mode Manager MCP figures out what you want to remember and where it belongs.

Contributing

Want to help make this better? The best contribution you can make is actually using it - your feedback and bug reports are what really drive improvements.

Of course, code contributions are welcome too! Check out CONTRIBUTING.md for development setup and guidelines. But seriously, just using it and telling us what works (or doesn't) is incredibly valuable.

License

MIT License - see LICENSE for details.

Available Tools

9 tools

configure_memory_optimizationConfigure Memory OptimizationC

Configure memory optimization settings for auto-optimization behavior.

ParametersJSON Schema

Name	Required	Description	Default
`memory_file`	No
`auto_optimize`	No
`token_growth_threshold`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

C2.3/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already indicate mutation (readOnlyHint=false) and non-idempotency. Description adds no additional behavioral details such as side effects, permissions, or state changes.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness2/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Extremely concise at 6 words, but under-specification for a tool with 3 parameters and no schema descriptions. Conciseness sacrifices necessary detail.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness1/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given zero parameter descriptions and missing output schema explanation, the description is insufficient for correct tool invocation. Lacks parameter meanings and usage scenarios.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0% and description does not explain any of the three parameters (memory_file, auto_optimize, token_growth_threshold). Agent has no semantic guidance for input values.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states the tool configures memory optimization settings for auto-optimization behavior. It distinguishes from sibling 'optimize_memory' by focusing on configuration rather than execution.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance provided on when to use this tool versus alternatives like 'optimize_memory' or 'memory_stats'. Agent must infer context from tool names.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

create_instructionCreate InstructionA

Create a new VS Code .instructions.md file with the specified description and content.

ParametersJSON Schema

Name	Required	Description
`instruction_name`	Yes	The name for the new instruction (with or without extension)
`description`	Yes	A brief description of what this instruction does
`content`	Yes	The main content/instructions in markdown format

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A3.5/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=false and idempotentHint=false, so the description does not need to repeat those. However, the description does not clarify what happens if the instruction_name already exists (e.g., overwrite or error), nor does it discuss side effects. It adds minor context by specifying the file type.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, short sentence (14 words) that directly conveys the purpose. It is front-loaded with the action and resource, and every word is necessary. There is no redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

While the tool has an output schema (not shown), the description does not explain the output or edge cases like naming conflicts or content limits. It covers the basic function but lacks completeness for a creation tool with multiple parameters and potential duplicates.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so baseline is 3. The description mentions 'description and content' but adds no additional semantic details beyond the schema descriptions. No parameter-specific guidance is provided.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool creates a new VS Code .instructions.md file with specified description and content. It uses specific verb 'create' and resource 'VS Code .instructions.md file', which distinguishes it from siblings like update_instruction or delete_instruction.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives such as update_instruction. There is no mention of prerequisites, constraints, or situations where using this tool is inappropriate. The description only implies usage for new instructions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

delete_instructionDelete InstructionA

Delete a VS Code .instructions.md file from the prompts directory.

ParametersJSON Schema

Name	Required	Description	Default
`instruction_name`	Yes	The name of the instruction to delete (with or without extension)

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A3.5/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already indicate this tool is not read-only and not idempotent, which is consistent with deletion. The description adds the file type and directory location, but does not disclose critical behavioral details like whether deletion is permanent, if confirmation is needed, or error handling for missing files. With annotations covering the safety profile, the minimal addition is acceptable but not exceptional.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, clear sentence with no wasted words. It fits on one line and immediately conveys the tool's core action and resource.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the output schema exists, the description doesn't need to detail return values. However, it omits practical details like what happens on success, failure cases (e.g., file not found), and whether the operation is reversible. For a deletion tool of this nature, the description is adequate but leaves common questions unanswered.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Input schema coverage is 100%, so the schema already documents the single parameter 'instruction_name' with the description 'with or without extension'. The tool description does not elaborate further on parameter meaning, formatting, or valid values, offering no added value beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description precisely states the action ('Delete') and the resource ('a VS Code .instructions.md file from the prompts directory'), making the tool's purpose unmistakable. It clearly distinguishes itself from sibling tools like create_instruction, get_instruction, update_instruction, and list_instructions by specifying the delete operation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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, such as when to delete vs. update or list instructions. No contextual cues or exclusions are provided, leaving an AI agent without decision-making support for tool selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_instructionGet InstructionA

Read-onlyIdempotent

Get the raw content of a VS Code .instructions.md file.

ParametersJSON Schema

Name	Required	Description	Default
`instruction_name`	Yes	Name of the instruction (without extension)

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A3.7/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already indicate readOnlyHint and idempotentHint; the description adds context about retrieving raw content from a specific file type, but does not elaborate on behavior beyond that.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that efficiently conveys the tool's function without redundancy, though it could include slightly more detail without becoming verbose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple read tool with one parameter and an existing output schema, the description covers the essential purpose and input; no missing critical details.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so baseline is 3; the description does not add meaning beyond the schema, as it only explains that the parameter is the instruction name without extension.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly specifies the verb 'Get' and the resource 'raw content of a VS Code .instructions.md file', making the tool's purpose distinct from siblings like 'create_instruction' or 'list_instructions'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use this tool versus alternatives; the description implies it's for retrieving instruction content but does not provide when-not-to-use or alternative suggestions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_instructionsList InstructionsA

Read-onlyIdempotent

List all VS Code .instructions.md files in the prompts directory.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A4.3/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already provide readOnlyHint=true and idempotentHint=true, covering safety. Description adds scope (prompts directory) and file type (.instructions.md), which is useful context beyond annotations. No additional behavioral details needed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence, 10 words, no waste. Every word adds value. Perfectly concise for a simple listing tool.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter, list-only tool with output schema, description is fully adequate. It clearly identifies what is listed and scope. No missing information.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

No parameters exist; schema coverage is 100%. Baseline for 0 params is 4. Description adds no parameter info, which is appropriate given no parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description clearly states 'List all VS Code .instructions.md files in the prompts directory.' Verb 'List' and resource specified precisely. Distinguished from sibling tools like create, delete, get, update, making its purpose unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance on when to use vs alternatives. However, the sibling names imply use for listing all files; for specific files, use get_instruction. Missing explicit when-not or alternative comparisons, but context is clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

memory_statsMemory File StatisticsC

Read-onlyIdempotent

Get detailed statistics and optimization status for a memory file.

ParametersJSON Schema

Name	Required	Description	Default
`memory_file`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

C2.9/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description's claim of 'Get' is consistent but not additive. The description adds that it provides 'statistics and optimization status,' which is useful but superficial; it does not disclose any behavioral traits beyond what annotations imply.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise at one sentence and 12 words. It is front-loaded with the verb 'Get' and contains no extraneous information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite the tool being simple with one optional parameter and an output schema, the description lacks details about what statistics are returned, what optimization status means, and how the input should be specified. It leaves significant gaps.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With 0% schema description coverage and no explanation of the 'memory_file' parameter in the description, the agent has no semantic understanding of this optional parameter. The description does not compensate for the schema gap.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states what the tool does: 'Get detailed statistics and optimization status for a memory file.' It uses a specific verb and resource, and its purpose is distinct from sibling tools like 'optimize_memory' and 'configure_memory_optimization'. However, it does not explicitly differentiate from these siblings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 'optimize_memory' or 'configure_memory_optimization'. It simply describes the action without context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

optimize_memoryOptimize Memory FileB

Manually optimize a memory file using AI to reorganize and consolidate entries while preserving all information.

ParametersJSON Schema

Name	Required	Description	Default
`memory_file`	No
`force`	No	Force optimization regardless of criteria

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

B3.4/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already indicate this is a write operation (readOnlyHint=false) and non-idempotent (idempotentHint=false). The description adds that it reorganizes and consolidates entries while preserving information, which is helpful but does not disclose any side effects, permission requirements, or failure modes.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that is front-loaded with the action and provides key details. No extraneous words or redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the simple tool with 2 params and an output schema, the description explains the core functionality but omits usage context (e.g., when to call manually vs. automated), potential performance considerations, and what the output contains. It is adequate but not thorough.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 50% (only force has a description). The tool description does not mention any parameters, so it adds no meaning beyond what the schema provides. It fails to compensate for the undocumented memory_file parameter.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb (optimize) and resource (memory file), and clearly distinguishes from siblings like configure_memory_optimization (configuration) and remember (adding entries). It is unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description does not provide when-to-use or when-not-to-use guidance. It mentions 'manually' but does not contrast with automatic optimization or reference sibling tools. No exclusions or alternatives are given.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

rememberRememberA

Idempotent

Store user information persistently for future conversations. When users share preferences, coding standards, project details, or any context they want remembered, use this tool. Extract the key information from natural language and store it appropriately. The system automatically detects scope (user/workspace) and language specificity from context. For ambiguous cases, you will receive clarification prompts to ask the user. Examples of what to remember: coding preferences ('I like detailed docstrings'), project specifics ('This app uses PostgreSQL'), language standards ('For Python, use type hints'), workflow preferences ('Always run tests before committing'). Use only the memory_item parameter with natural language - the system handles scope detection.

ParametersJSON Schema

Name	Required	Description	Default
`memory_item`	Yes	The information to remember
`scope`	No	Memory scope: 'user' (default) or 'workspace'	user
`language`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A3.8/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Adds details about automatic scope/language detection and natural language input, but contradicts the schema by advising to 'use only memory_item' while schema exposes scope and language parameters.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Well-structured with examples, but slightly verbose; could tighten the guidance on parameter usage.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Covers use cases, examples, and auto-detection behavior, but could clarify the role of the optional parameters and expected return values.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Provides context for memory_item but downplays scope and language parameters despite their existence in the schema, creating confusion for the agent.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool stores persistent context, gives concrete examples, and differentiates from sibling tools like configure_memory_optimization.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly describes when to use (e.g., preferences, coding standards) and mentions clarification prompts for ambiguity, but lacks explicit when-not-to-use guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

update_instructionUpdate InstructionA

Update an existing VS Code .instructions.md file with new description or content.

ParametersJSON Schema

Name	Required	Description
`instruction_name`	Yes	The name of the instruction to update (with or without extension)
`description`	No
`content`	No

Output Schema

ParametersJSON Schema

Name	Required	Description
`result`	Yes

TDQS

A3.8/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already indicate readOnlyHint=false and idempotentHint=false. Description adds no additional behavioral context such as whether the tool overwrites or merges fields, or if there are side effects. No contradiction found.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

A single sentence that efficiently conveys the tool's purpose without extraneous detail. Every word earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple update tool, the description covers the main purpose. An output schema exists to document return values. However, missing details on whether updates are overwrite or merge could be helpful.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 33% (only instruction_name has description). Description mentions 'new description or content', mapping to two parameters, but does not add format or constraints beyond parameter names. Baseline score of 3 is appropriate given self-explanatory names.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Description uses specific verb 'update' and clearly identifies the resource as 'existing VS Code .instructions.md file'. It distinguishes from sibling tools like create_instruction, delete_instruction, and get_instruction.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Description implies usage context (updating existing instruction), but there is no explicit guidance on when to use this tool versus alternatives or when not to use it. No mention of prerequisites or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

10 tool updatesv2.0.1Apr 30, 2026

Removedbrowse_mode_library

Changedconfigure_memory_optimization4 fields changed

removedInput schema / properties / entry_threshold

Removed value: -{
-  "anyOf": [
-    {
-      "type": "integer"
-    },
-    {
-      "type": "null"
-    }
-  ],
-  "default": null
-}

removedInput schema / properties / size_threshold

Removed value: -{
-  "anyOf": [
-    {
-      "type": "integer"
-    },
-    {
-      "type": "null"
-    }
-  ],
-  "default": null
-}

removedInput schema / properties / time_threshold_days

Removed value: -{
-  "anyOf": [
-    {
-      "type": "integer"
-    },
-    {
-      "type": "null"
-    }
-  ],
-  "default": null
-}

addedInput schema / properties / token_growth_threshold

Added value: +{
+  "anyOf": [
+    {
+      "type": "number"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "default": null
+}

Removedcreate_chatmode
Removeddelete_chatmode
Removedget_chatmode
Removedinstall_from_library
Removedlist_chatmodes
Removedrefresh_library
Removedupdate_chatmode
Removedupdate_chatmode_from_source

18 tool updatesv1.0.0Jan 3, 2026
- Changedbrowse_mode_library4 fields changed
  - removedInput schema / properties / category / title
```
Removed value: -"Category"
```
  - removedInput schema / properties / search / title
```
Removed value: -"Search"
```
  - removedOutput schema / properties / result / title
```
Removed value: -"Result"
```
  - removedOutput schema / title
```
Removed value: -"_WrappedResult"
```
- Changedconfigure_memory_optimization7 fields changed
  - removedInput schema / properties / auto_optimize / title
```
Removed value: -"Auto Optimize"
```
  - removedInput schema / properties / entry_threshold / title
```
Removed value: -"Entry Threshold"
```
  - removedInput schema / properties / memory_file / title
```
Removed value: -"Memory File"
```
  - removedInput schema / properties / size_threshold / title
```
Removed value: -"Size Threshold"
```
  - removedInput schema / properties / time_threshold_days / title
```
Removed value: -"Time Threshold Days"
```
  - removedOutput schema / properties / result / title
```
Removed value: -"Result"
```
  - removedOutput schema / title
```
Removed value: -"_WrappedResult"
```
- Changedcreate_chatmode6 fields changed
  - removedInput schema / properties / content / title
```
Removed value: -"Content"
```
  - removedInput schema / properties / description / title
```
Removed value: -"Description"
```
  - removedInput schema / properties / filename / title
```
Removed value: -"Filename"
```
  - removedInput schema / properties / tools / title
```
Removed value: -"Tools"
```
  - removedOutput schema / properties / result / title
```
Removed value: -"Result"
```
  - removedOutput schema / title
```
Removed value: -"_WrappedResult"
```
- Changedcreate_instruction5 fields changed
  - removedInput schema / properties / content / title
```
Removed value: -"Content"
```
  - removedInput schema / properties / description / title
```
Removed value: -"Description"
```
  - removedInput schema / properties / instruction_name / title
```
Removed value: -"Instruction Name"
```
  - removedOutput schema / properties / result / title
```
Removed value: -"Result"
```
  - removedOutput schema / title
```
Removed value: -"_WrappedResult"
```
- Changeddelete_chatmode3 fields changed
  - removedInput schema / properties / filename / title
```
Removed value: -"Filename"
```
  - removedOutput schema / properties / result / title
```
Removed value: -"Result"
```
  - removedOutput schema / title
```
Removed value: -"_WrappedResult"
```
- Changeddelete_instruction3 fields changed
  - removedInput schema / properties / instruction_name / title
```
Removed value: -"Instruction Name"
```
  - removedOutput schema / properties / result / title
```
Removed value: -"Result"
```
  - removedOutput schema / title
```
Removed value: -"_WrappedResult"
```
- Changedget_chatmode3 fields changed
  - removedInput schema / properties / filename / title
```
Removed value: -"Filename"
```
  - removedOutput schema / properties / result / title
```
Removed value: -"Result"
```
  - removedOutput schema / title
```
Removed value: -"_WrappedResult"
```
- Changedget_instruction3 fields changed
  - removedInput schema / properties / instruction_name / title
```
Removed value: -"Instruction Name"
```
  - removedOutput schema / properties / result / title
```
Removed value: -"Result"
```
  - removedOutput schema / title
```
Removed value: -"_WrappedResult"
```
- Changedinstall_from_library4 fields changed
  - removedInput schema / properties / filename / title
```
Removed value: -"Filename"
```
  - removedInput schema / properties / name / title
```
Removed value: -"Name"
```
  - removedOutput schema / properties / result / title
```
Removed value: -"Result"
```
  - removedOutput schema / title
```
Removed value: -"_WrappedResult"
```
- Changedlist_chatmodes2 fields changed
  - removedOutput schema / properties / result / title
```
Removed value: -"Result"
```
  - removedOutput schema / title
```
Removed value: -"_WrappedResult"
```
- Changedlist_instructions2 fields changed
  - removedOutput schema / properties / result / title
```
Removed value: -"Result"
```
  - removedOutput schema / title
```
Removed value: -"_WrappedResult"
```
- Changedmemory_stats3 fields changed
  - removedInput schema / properties / memory_file / title
```
Removed value: -"Memory File"
```
  - removedOutput schema / properties / result / title
```
Removed value: -"Result"
```
  - removedOutput schema / title
```
Removed value: -"_WrappedResult"
```
- Changedoptimize_memory4 fields changed
  - removedInput schema / properties / force / title
```
Removed value: -"Force"
```
  - removedInput schema / properties / memory_file / title
```
Removed value: -"Memory File"
```
  - removedOutput schema / properties / result / title
```
Removed value: -"Result"
```
  - removedOutput schema / title
```
Removed value: -"_WrappedResult"
```
- Changedrefresh_library2 fields changed
  - removedOutput schema / properties / result / title
```
Removed value: -"Result"
```
  - removedOutput schema / title
```
Removed value: -"_WrappedResult"
```
- Changedremember5 fields changed
  - removedInput schema / properties / language / title
```
Removed value: -"Language"
```
  - removedInput schema / properties / memory_item / title
```
Removed value: -"Memory Item"
```
  - removedInput schema / properties / scope / title
```
Removed value: -"Scope"
```
  - removedOutput schema / properties / result / title
```
Removed value: -"Result"
```
  - removedOutput schema / title
```
Removed value: -"_WrappedResult"
```
- Changedupdate_chatmode6 fields changed
  - removedInput schema / properties / content / title
```
Removed value: -"Content"
```
  - removedInput schema / properties / description / title
```
Removed value: -"Description"
```
  - removedInput schema / properties / filename / title
```
Removed value: -"Filename"
```
  - removedInput schema / properties / tools / title
```
Removed value: -"Tools"
```
  - removedOutput schema / properties / result / title
```
Removed value: -"Result"
```
  - removedOutput schema / title
```
Removed value: -"_WrappedResult"
```
- Changedupdate_chatmode_from_source3 fields changed
  - removedInput schema / properties / filename / title
```
Removed value: -"Filename"
```
  - removedOutput schema / properties / result / title
```
Removed value: -"Result"
```
  - removedOutput schema / title
```
Removed value: -"_WrappedResult"
```
- Changedupdate_instruction5 fields changed
  - removedInput schema / properties / content / title
```
Removed value: -"Content"
```
  - removedInput schema / properties / description / title
```
Removed value: -"Description"
```
  - removedInput schema / properties / instruction_name / title
```
Removed value: -"Instruction Name"
```
  - removedOutput schema / properties / result / title
```
Removed value: -"Result"
```
  - removedOutput schema / title
```
Removed value: -"_WrappedResult"
```
18 tool updatesAug 15, 2025
- First observedbrowse_mode_library
- First observedconfigure_memory_optimization
- First observedcreate_chatmode
- First observedcreate_instruction
- First observeddelete_chatmode
- First observeddelete_instruction
- First observedget_chatmode
- First observedget_instruction
- First observedinstall_from_library
- First observedlist_chatmodes
- First observedlist_instructions
- First observedmemory_stats
- First observedoptimize_memory
- First observedrefresh_library
- First observedremember
- First observedupdate_chatmode
- First observedupdate_chatmode_from_source
- First observedupdate_instruction

Deploy Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3.3/5.0

Scored 2026-04-30 16:50 across 9 tools

Disambiguation5/5

Each tool targets a specific action: memory optimization settings, instruction CRUD, storage, and statistics. There is no overlap; 'remember' and 'optimize_memory' are clearly distinct.

Naming Consistency3/5

Most tools follow verb_noun pattern (e.g., create_instruction, list_instructions), but 'memory_stats' is noun_noun and 'remember' is a single verb, breaking consistency.

Tool Count5/5

9 tools cover two domains (5 for instructions, 4 for memory optimization) without being excessive or insufficient for the stated purpose.

Completeness3/5

Instruction management has full CRUD, but memory management lacks tools to list, get, or delete stored memories, leaving noticeable gaps in the workflow.

Maintenance

ActivityInactive

ResponsivenessNo issues

Resources

GitHub Repository

Need Help?

Reddit Discussion

Related Servers

Related MCP Connectors

llm-orchestration-agent-mcp
ai.getvda
LLM Orchestration Agent (Mcp)
Agent Orchestration Autonomous Agents
1
ContextStream BOAuth
io.contextstream
Persistent memory and cross-session learning for AI coding assistants (hosted remote MCP).
Knowledge & Memory Developer Tools
30242
hithereiamaliff-mcp-nextcloudOAuth
ai.smithery
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Cloud Storage File Systems Workplace & Productivity
237
Jade NoteOAuth
app.jadenote
MCP-native notes and memory for ChatGPT, Claude, and other AI tools.
Note Taking Knowledge & Memory
2

Related MCP Servers

vscode-mcp-server
Developer Tools Code Execution Command Line
juehang
A
license
A
quality
D
maintenance
MCP server to expose VS Code editing features to an LLM for AI coding
Updated 8 months ago (2026-01-07 15:40 UTC)
9
106
392
MIT
repo-memory-mcp
Knowledge & Memory Developer Tools
andyast
A
license
C
quality
D
maintenance
MCP server for sharing source-backed engineering memory across AI coding clients like Cursor and VS Code.
Updated 4 months ago (2026-05-12 00:27 UTC)
30
1
MIT
Thread Keeper
Knowledge & Memory Autonomous Agents Agent Orchestration
po4erk91
A
license
B
quality
B
maintenance
Multi-agent shared brain MCP server enabling cross-session memory, self-improving skill loops, and inter-agent signaling across Claude, Codex, Gemini, Copilot, and VS Code CLI agents.
Updated 13 hours ago (2026-09-12 08:54 UTC)
127
12
MIT
Vertiso Memoryofficial
Knowledge & Memory Developer Tools
Vertiso
A
license
Not graded
quality
B
maintenance
A portable, user-owned memory for MCP-capable agents in VS Code, enabling cross-agent recall and memory creation.
Updated 15 days ago (2026-08-29 06:18 UTC)
MIT

Meet #remember -- Real Memory for You, Your Team, and Your AI

Why “Remember”? (Features & Benefits)

Real-World Examples: Just Say It!

Get It Running (2 Minutes)

Option 1: One-Click Install (Easiest)

Option 2: Manual Configuration

Option 3: Development / Testing (Latest from GitHub)

Bonus: Interactive Onboarding

For Development / Testing Latest from GitHub

Under the Hood: How Memory Magic Happens

Memory Scopes

How Memory is Stored

How Memory is Loaded

No Special Syntax Needed

Contributing

License

Available Tools

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Tool Schema Changelog

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

Vertiso Memoryofficial