MCP Notes

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.0
Disambiguation4/5
Most tools have distinct purposes, such as create_directory for directory creation, read_note for reading single files, and rollup for synthesizing daily notes. However, there is some overlap between read_note and read_multiple_notes, as both handle reading files, which could cause minor confusion, but their descriptions clarify the distinction (single vs. multiple files).
Naming Consistency3/5
The naming conventions are mixed, with most tools using snake_case (e.g., create_directory, list_directory) and one using camelCase (evaluateInsight). This inconsistency reduces predictability, but the names are still readable and generally follow a verb_noun pattern, except for evaluateInsight which deviates in style.
Tool Count5/5
With 9 tools, the count is well-scoped for a notes management server, covering core operations like creating, reading, writing, listing, searching, and synthesizing notes. Each tool serves a clear purpose, and there is no bloat or missing essential functions, making the set appropriately sized for the domain.
Completeness4/5
The tool set provides comprehensive coverage for notes management, including CRUD-like operations (create, read, write), directory handling, searching, and advanced features like rollup and insight evaluation. A minor gap exists in update operations for notes or directories, as write_note only allows overwriting, but agents can work around this with existing tools.
Average 3.6/5 across 9 of 9 tools scored. Lowest: 2.9/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
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 mentions 'create or update' but doesn't clarify what happens if a log already exists, whether updates are destructive or additive, or any permissions, rate limits, or error handling. The description adds minimal context beyond the basic operation.
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 concise and front-loaded with the core purpose in the first sentence. The second sentence adds optional functionality without redundancy. Both sentences earn their place by clarifying the tool's scope, though it could be slightly more structured (e.g., by explicitly stating parameters).
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 tool has 2 required parameters, no annotations, no output schema, and 50% schema coverage, the description is incomplete. It doesn't explain what the tool returns, how errors are handled, or the full behavioral context for a mutation tool. The description alone is inadequate for safe and effective use by an AI agent.
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 50%, with the 'tags' parameter well-documented in the schema but 'notes' lacking description. The tool description adds no parameter semantics beyond what's in the schema—it mentions 'optionally add notes' but doesn't explain the 'notes' parameter's purpose or format. The baseline is 3 because the schema covers half the parameters, but the description doesn't compensate for the 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 the tool's purpose: 'Create or update today's daily log file. Optionally add notes to the log.' This specifies the verb (create/update), resource (today's daily log file), and optional functionality (add notes). It distinguishes from siblings like 'write_note' by focusing on a daily log file rather than general notes, though it doesn't explicitly contrast with all 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. It doesn't mention when to choose 'log' over 'write_note' or other sibling tools like 'create_directory' or 'search_files', nor does it specify prerequisites or exclusions. Usage is implied only by the tool's name and purpose.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only partially discloses behavior. It states the tool can create or overwrite notes and merge tags, but doesn't cover permissions, error handling, or response format. 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose and efficiently covers key points in two sentences without redundancy. Every sentence adds necessary information, making it appropriately sized and well-structured.
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?
For a mutation tool with no annotations and no output schema, the description is incomplete. It lacks details on permissions, error cases, response format, and how overwriting interacts with existing data beyond tags, leaving significant gaps for agent understanding.
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 the schema fully documents parameters. The description adds minimal value by clarifying tag merging behavior and path relativity, but doesn't provide additional syntax or format details beyond what the schema already specifies.
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 the action ('Create a new note or overwrite an existing note') and resource ('note with content'), distinguishing it from read operations like read_note. However, it doesn't explicitly differentiate from other write-related siblings like create_directory or log, which slightly reduces specificity.
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 explicit guidance on when to use this tool versus alternatives is provided. The description mentions path relativity and tag merging, but lacks context on prerequisites, error conditions, or comparisons to siblings like create_directory or log, leaving usage decisions ambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 describes the evaluation criteria and what to ignore, but it doesn't disclose key behavioral traits such as how the evaluation is performed (e.g., algorithmic vs. manual), what the output looks like, whether it's a read-only or mutating operation, or any rate limits or permissions required. For a tool with 8 parameters and no 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and well-structured, using bullet points to list criteria and insights to ignore, making it easy to scan. It's front-loaded with the main purpose and avoids unnecessary fluff. However, it could be slightly more concise by integrating the criteria list more tightly, but overall, it's efficient and clear.
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 8 parameters, 0% schema description coverage, no annotations, and no output schema, the description is incomplete. It covers the evaluation criteria and exclusions but fails to explain the full parameter set, behavioral aspects, or expected outputs. For a tool with this level of complexity and no structured support, the description should provide more comprehensive guidance to be effective.
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%, meaning none of the 8 parameters are documented in the schema. The description only partially compensates by listing the four criteria (actionability, longevity, findability, future reference value), which correspond to 4 of the 8 parameters. However, it doesn't explain the other parameters (e.g., 'thought', 'evaluationStep', 'totalSteps', 'nextStepNeeded'), leaving them undocumented. This incomplete coverage reduces the tool's usability.
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 the tool's purpose: to evaluate the long-term value and significance of an insight based on specific criteria (actionability, longevity, findability, future reference value). It specifies the verb 'evaluate' and the resource 'insight or thought', making the function unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'log' or 'rollup', which might also involve processing insights, though the evaluation focus is distinct.
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?
The description provides clear context for when to use this tool: for evaluating insights based on long-term value criteria. It includes explicit guidelines on what types of insights to ignore (trivial syntax details, redundant information), which helps in decision-making. However, it doesn't mention when not to use it or name specific alternatives among sibling tools, such as 'log' for simple recording or 'rollup' for summarization.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 states the tool can create nested directories in one operation, which adds useful behavioral context beyond basic creation. However, it fails to disclose critical traits such as permissions needed, error handling (e.g., if path exists), or mutation effects, leaving significant gaps for a tool that modifies the file system.
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 appropriately sized with two sentences that are front-loaded and efficient. Each sentence earns its place by stating the core action and providing key operational details (nested creation and path relativity), with zero wasted words.
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 tool's complexity (a mutation operation with no annotations and no output schema), the description is incomplete. It covers the basic action and path handling but lacks details on permissions, error cases, or return values. While concise, it doesn't fully compensate for the missing structured data, making it adequate but with clear gaps for safe agent use.
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?
The input schema has 100% description coverage, clearly documenting the single 'path' parameter. The description adds minimal value by reiterating that the path is relative to the notes directory, which is already in the schema. This meets the baseline of 3, as the schema does the heavy lifting without needing extra semantic details from the description.
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 the tool's purpose with a specific verb ('Create') and resource ('directory in your notes'), and distinguishes it from sibling tools like 'list_directory' or 'write_note'. However, it doesn't explicitly differentiate from potential similar operations (e.g., 'create' vs. 'write' for files), keeping it from a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for creating directories in notes, including nested ones, but provides no explicit guidance on when to use this tool versus alternatives (e.g., 'write_note' for files or 'list_directory' for checking existence). It mentions the path should be relative, which offers some context but lacks exclusions or clear alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses behavioral traits like quality filtering ('only include notes that add long-term value'), optional actions ('call /evaluateInsight'), and error handling ('stop and ask the user'). However, it doesn't cover potential side effects, rate limits, or authentication needs, leaving gaps for a mutation-like tool.
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 appropriately sized with four sentences, each adding value: purpose, quality criteria, alternative tool reference, and error handling. It's front-loaded with the core purpose. However, some phrasing could be tighter, such as 'It is better to not log anything than log something that is not useful,' which is slightly redundant.
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 no annotations and no output schema, the description is moderately complete. It covers purpose, usage guidelines, and some behavioral aspects but lacks details on output format, error responses, or system constraints. For a tool with 4 parameters and mutation-like behavior, more contextual information would improve completeness.
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 75%, with clear descriptions for 'accomplishments', 'insights', and 'todos'. The description adds minimal parameter semantics beyond the schema, only mentioning 'Optionally specify a date (YYYY-MM-DD)' for the 'date' parameter. Since schema coverage is high, the baseline is 3, and the description provides slight additional context.
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 the tool's purpose: 'Synthesize my daily note to create an organized rollup of the most important notes with clear categories, connections, and action items.' It specifies the verb 'synthesize' and resource 'daily note,' with output details. However, it doesn't explicitly differentiate from siblings like 'log' or 'write_note' beyond mentioning '/evaluateInsight' as an alternative for evaluation.
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?
The description provides clear usage context: 'Only include notes that actually add long-term value' and references '/evaluateInsight' for uncertain cases. It also advises to 'stop and ask the user for more information' if needed. However, it lacks explicit when-not-to-use guidance or comparisons to all sibling tools (e.g., vs. 'log' or 'write_note').
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 discloses that the tool 'Shows all files and directories with clear labels,' which adds useful behavioral context about the output format. However, it does not mention potential errors (e.g., if the path doesn't exist), permissions, or pagination, leaving gaps for a mutation-free tool.
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 front-loaded with the core purpose in the first sentence, followed by additional details in a second sentence. Every sentence earns its place by clarifying scope and usage, with zero wasted words, making it highly efficient and well-structured.
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?
Given the tool's low complexity (single optional parameter, no output schema, no annotations), the description is largely complete. It covers purpose, usage, and parameter context adequately. A 5 would require addressing minor gaps like error handling or output details, but it's sufficient for basic directory listing.
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 the schema already documents the 'path' parameter thoroughly. The description adds marginal value by reinforcing the path specification ('Specify path relative to your notes directory') and providing an example ('e.g., 'Log' or 'Rollups''), but does not add significant meaning beyond the schema. Baseline 3 is appropriate.
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 specific action ('List the contents of a directory') and resource ('in your notes'), distinguishing it from siblings like read_note (read file content) or search_files (search across files). It specifies the scope ('Shows all files and directories with clear labels'), making the 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 Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool ('List the contents of a directory in your notes') and includes a usage example ('Specify path relative to your notes directory'). However, it does not explicitly state when not to use it or name alternatives like search_files for filtered searches, which would have earned a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It discloses the return behavior ('Returns the full text content of the note file') and path specification requirement. However, it doesn't mention error handling (e.g., what happens if file doesn't exist), permissions, or file format constraints.
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?
Two sentences, zero waste. First sentence states purpose and input, second sentence states output. Every element earns its place, and the description is appropriately sized for a simple read operation.
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 operation with 100% schema coverage and no output schema, the description is mostly complete. It covers purpose, input specification with example, and return value. The main gap is lack of error handling information, which would be helpful given no annotations.
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 the schema already fully documents the single 'path' parameter. The description adds a helpful example ('e.g., 'Log/2023-01-01.md'') but doesn't provide additional semantic meaning beyond what the schema states. Baseline 3 is appropriate when schema does the heavy lifting.
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 specific action ('Read the complete contents'), resource ('a note file from your notes directory'), and scope ('complete contents'). It distinguishes from siblings like 'read_multiple_notes' (single vs multiple) and 'write_note' (read vs write).
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?
The description provides clear context about when to use this tool ('Read the complete contents of a note file') and implies when not to use it (for multiple notes, use 'read_multiple_notes'; for writing, use 'write_note'). However, it doesn't explicitly name alternatives or provide exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/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 describes the action (reading multiple files) and the return format (content with paths), which is useful. However, it lacks details on error handling (e.g., what happens if a file doesn't exist), performance implications (e.g., rate limits or size constraints), or permissions required, leaving gaps in behavioral context.
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 front-loaded with the core purpose in the first sentence, followed by specific usage details and return information. Every sentence adds essential value without redundancy, making it efficient and well-structured for quick comprehension.
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 tool's moderate complexity (reading multiple files) and no output schema, the description adequately covers the basic operation and return format. However, it lacks details on error cases, performance limits, or how it interacts with sibling tools, which could be important for complete contextual understanding in a notes management system.
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?
The input schema has 100% description coverage, so the schema already documents the single parameter 'paths' thoroughly. The description adds value by providing an example (e.g., ['Log/2023-01-01.md', 'Rollups/2023-01-01-rollup.md']) and clarifying that paths are relative to the notes directory, enhancing understanding beyond the schema's basic definition.
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 specific action ('Read the contents') and resource ('multiple note files simultaneously'), distinguishing it from sibling tools like 'read_note' (singular) and 'search_files' (searching rather than direct reading). It precisely communicates the tool's function without ambiguity.
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?
The description provides clear context by specifying that paths are relative to the notes directory and giving examples, which helps users understand when to use this tool. However, it does not explicitly state when to use this versus alternatives like 'read_note' for single files or 'search_files' for finding files, missing explicit guidance on exclusions or comparisons.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden and does well by disclosing key behavioral traits: it's a read-only search (implied by 'search'), recursive, case-insensitive, matches partial names, and returns full paths. It doesn't mention rate limits, permissions, or error handling, but covers the core operation adequately for a search tool.
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 appropriately sized and front-loaded: the first sentence covers the core functionality, the second adds behavioral details, and the third provides usage context. Every sentence earns its place with no wasted words, making it efficient and easy to scan.
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?
Given the tool's moderate complexity (search with two parameters), no annotations, and no output schema, the description is fairly complete: it explains what the tool does, how it behaves, and when to use it. It lacks details on output format beyond 'full paths' (e.g., structure or pagination) and doesn't cover edge cases, but it's sufficient for basic use.
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 the schema already documents both parameters (pattern and excludePatterns). The description adds some context by mentioning 'pattern' is matched in names and search is 'case-insensitive' and 'partial', but doesn't provide additional syntax or format details beyond what the schema implies. Baseline 3 is appropriate as the schema does the heavy lifting.
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's purpose with specific verbs ('recursively search for files and directories') and resources ('in your notes directory'), distinguishing it from siblings like list_directory (which lists without searching) or read_note (which reads specific files). It explicitly mentions what it returns ('full paths to all matching items').
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?
The description provides clear context for when to use this tool ('Great for finding notes when you don't know their exact location'), which implicitly differentiates it from tools like read_note (for known files) or list_directory (for browsing). However, it doesn't explicitly state when not to use it or name alternatives like evaluateInsight or rollup, which might serve different search purposes.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![mcp-notes MCP server](https://glama.ai/mcp/servers/markacianfrani/mcp-notes/badges/card.svg)](https://glama.ai/mcp/servers/markacianfrani/mcp-notes)

Score Badge

Copy to your README.md:

[![mcp-notes MCP server](https://glama.ai/mcp/servers/markacianfrani/mcp-notes/badges/score.svg)](https://glama.ai/mcp/servers/markacianfrani/mcp-notes)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

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/markacianfrani/mcp-notes'

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