Skip to main content
Glama
truaxki

MCP Notes Server

by truaxki

update-note

Modify existing notes on the MCP Notes Server by updating their name and content. Use this tool to ensure your notes stay current and accurate.

Instructions

Update an existing note

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
contentYes
nameYes

Implementation Reference

  • The _handle_update_note method that executes the tool logic for updating a note, including validation and response formatting.
    async def _handle_update_note(self, arguments: Optional[Dict]) -> List[types.TextContent]:
        """Process note update requests."""
        if not arguments:
            raise ValueError("Missing arguments")
    
        note_name = arguments.get("name")
        content = arguments.get("content")
    
        if not note_name or not content:
            raise ValueError("Missing name or content")
    
        current_time, content = self.storage.update_note(note_name, content)
        return [
            types.TextContent(
                type="text",
                text=f"Updated note '{note_name}' with content: {content}\nModified at: {current_time}",
            )
        ]
  • Defines the input schema, name, and description for the update-note tool.
    types.Tool(
        name="update-note",
        description="Update an existing note",
        inputSchema={
            "type": "object",
            "properties": {
                "name": {"type": "string"},
                "content": {"type": "string"},
            },
            "required": ["name", "content"],
        },
    ),
  • MCP server registration for listing tools, which includes the update-note tool schema.
    @server.list_tools()
    async def handle_list_tools() -> list[types.Tool]:
        """Return list of available note management tools."""
        return tool_list.get_tool_list()
  • MCP server registration for calling tools, which routes update-note calls to the handler.
    @server.call_tool()
    async def handle_call_tool(name: str, arguments: dict | None) -> list[types.TextContent]:
        """Execute requested note management tool."""
        result = await tool_handler.handle_tool(name, arguments)
        await server.request_context.session.send_resource_list_changed()
        return result
  • Supporting method in NoteStorage that updates the note content and timestamps, used by the tool handler.
    def update_note(self, name: str, content: str) -> tuple[str, str]:
        """Update existing note's content and modified time."""
        if name not in self.notes:
            raise ValueError(f"Note '{name}' not found")
        
        current_time = datetime.now().isoformat()
        self.notes[name]["content"] = content
        self.notes[name]["modified_at"] = current_time
        self.save_notes()
        return current_time, content
Behavior2/5

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 'update' implies a mutation, but it doesn't disclose any behavioral traits such as required permissions, whether the update is reversible, error handling, or rate limits. This is a significant gap for a mutation tool with zero annotation coverage, making it minimally transparent.

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, efficient sentence with zero waste. It's appropriately sized and front-loaded, directly stating the tool's purpose without unnecessary elaboration. This exemplifies conciseness, though it may be overly brief given the lack of other 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?

Given the complexity of a mutation tool with no annotations, 0% schema coverage, and no output schema, the description is incomplete. It doesn't cover parameter meanings, behavioral aspects, usage context, or return values. This inadequacy makes it insufficient for effective agent use, as it leaves critical gaps in understanding.

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 0%, so the schema provides no parameter details. The description adds no meaning beyond the tool name; it doesn't explain what 'content' and 'name' parameters represent, their formats, or how they interact. This fails to compensate for the lack of schema documentation, leaving parameters largely undocumented.

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

Purpose3/5

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

The description 'Update an existing note' clearly states the verb ('update') and resource ('note'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'add-note' or 'delete-note' beyond the basic action, and it lacks specificity about what aspects of the note are updated. This makes it vague but adequate for minimum viability.

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. It doesn't mention prerequisites (e.g., that a note must exist to update it), contrast with 'add-note' for creation or 'delete-note' for removal, or specify any context for usage. This absence of guidance leaves the agent without direction on tool selection.

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

Install Server

Other Tools

Related Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/truaxki/mcp-notes'

If you have feedback or need assistance with the MCP directory API, please join our Discord server