yt-curator-mcp

Server Quality Checklist

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

Latest release: v0.1.0
Disambiguation4/5
Most tools target distinct resources/actions, but list_playlists and scan_inventory overlap slightly since both return playlist lists; the descriptions clarify that scan_inventory is the primary data-collection command. Overall, boundaries are clear.
Naming Consistency4/5
The set mostly follows a verb_noun pattern (list_*, get_*, find_*, merge_*, delete_*, remove_*). Exceptions like 'curation_report' and 'auth_status' are minor and still readable, so consistency is good but not perfect.
Tool Count5/5
With 12 tools, the server is well-scoped for a playlist curation domain. Each tool earns its place, covering inventory scanning, analysis, and actionable curation without unnecessary bloat.
Completeness4/5
The surface covers the full curation workflow: scan, analyze, merge, delete, and remove dead videos. Minor gaps exist (e.g., no playlist creation/renaming or single-video moves), but these are peripheral to the core purpose.
Average 3.7/5 across 12 of 12 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- No commit activity data available
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is failing
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

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description is truthful and the verb 'find' implies a read-only operation, but with no annotations, it doesn't explicitly disclose side effects or prerequisites. However, the operation is inherently non-destructive and the description aligns with the tool name, so it is acceptable but lacks extra detail.
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 front-loads the action and resource. It contains no filler or redundancy, making it highly concise and well-structured.
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?
The tool is simple and an output schema exists, so return values are covered. However, the description does not address the optional db_path parameter or provide any usage context, leaving some gaps for an agent to fill.
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?
The schema has one parameter, db_path, with 0% description coverage. The description does not mention the parameter at all, leaving the agent to infer its meaning from the name. No compensation is provided for the missing schema documentation.
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 'Find playlists with 0 videos' uses a specific verb and resource with a clear condition. It distinguishes from sibling tools like list_playlists (which lists all playlists) and find_duplicates, 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 Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no guidance on when to use this tool versus alternatives. Sibling tools such as list_playlists and curation_report exist, but no comparison or recommended context is provided.
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, the description carries the burden. It defines 'dead' as deleted/private/blocked and notes the all-playlists scope, which adds transparency. However, it does not disclose whether the operation is read-only, whether it requires network/auth, or any other side effects.
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, focused sentence with no filler words. It efficiently communicates the tool's purpose without redundancy.
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 having an output schema, the description fails to explain the meaning of db_path, any prerequisites (like authentication), or potential performance implications of scanning all playlists. The minimal description is adequate for a simple tool but not complete given the optional parameter and the breadth of 'all playlists'.
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 the description makes no mention of the db_path parameter. The optional parameter's purpose and default behavior remain completely unexplained, so the description adds no value in this dimension.
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 uses the specific verb 'Find' and clarifies the resource as 'deleted, private, or blocked videos' with the scope 'across all playlists'. This clearly distinguishes it from sibling tools like find_duplicates and remove_dead_videos.
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 identifying dead videos but does not explicitly state when to use this tool instead of alternatives like find_duplicates or remove_dead_videos. No exclusions are mentioned, so it relies on the name and sibling context.
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 present, so the description is the only safety signal. The verb 'List' implies a read-only operation, but it does not explicitly disclose side effects, authentication needs, or edge cases such as missing playlist_id. Still, it does not misrepresent the behavior.
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 with no filler words, immediately front-loaded with the action and target.
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 an output schema exists, the description lacks usage context, alternative references, and parameter details (db_path). For a simple listing tool, it is adequate but not fully complete, missing context that would help the agent select and invoke it correctly.
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?
The schema has 0% description coverage. The description implicitly references playlist_id via 'a specific playlist' but does not explain the optional db_path parameter or its effect. The description fails to compensate for the missing parameter documentation.
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 a specific verb ('List') and resource ('all videos in a specific playlist'), which distinguishes it from sibling tools like list_playlists that list playlists themselves.
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 gives no guidance on when to prefer this tool over siblings, nor any exclusions or alternative recommendations. It only states what it does, leaving the agent to infer usage from context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 disclosing behavior. It only says 'check,' which implies read-only, but it does not state whether the tool makes network calls, what 'valid' means (e.g., expiry checks), or what the output looks like. The description is too minimal to provide meaningful behavioral insight.
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 is front-loaded with the verb 'Check' and immediately specifies the resource. It is concise and appropriately sized for a zero-parameter utility.
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?
The tool is simple and has an output schema (so return format is covered), but the description does not place the tool in the broader workflow of the sibling tools. It lacks guidance on when to invoke it relative to playlist operations, making it minimally complete but with a clear gap in usage context.
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 tool has zero parameters, so there is nothing for the description to explain about parameter semantics. The baseline for no parameters is 4, and the description correctly focuses on the subject (OAuth credentials) without adding unnecessary detail.
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 ('Check') and resource ('OAuth credentials') and clearly conveys the tool's purpose: verifying credential configuration and validity. It is distinct from sibling tools, which all focus on playlist/inventory operations, making this a unique utility.
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 using it before making authenticated calls or setting up credentials. There is no mention of prerequisites, exclusion criteria, or preferred use cases, leaving the agent to infer context.
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 the core behavior (title similarity-based suggestion) and provides an example, but it does not explicitly state whether the operation is read-only, what side effects might occur, or any algorithm details. The basics are covered, but not deeply.
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 at two sentences, front-loaded with the action, and includes a practical example. Every word earns its place with no redundancy or filler.
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?
The tool is relatively simple, has an output schema, and the description covers purpose and use case. However, the unexplained db_path parameter and lack of workflow guidance (e.g., prerequisites or relationship to other tools) leave noticeable gaps in completeness.
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 the only parameter (db_path) is not mentioned in the description at all. The tool description provides no guidance on what db_path refers to or when to supply it, so the description completely fails to compensate for the lack of schema-level parameter documentation.
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 'suggest playlist merge candidates based on title similarity,' using a specific verb and resource. It distinguishes itself from siblings like merge_playlists (actual merging) and find_duplicates (duplicate detection) by focusing on similarity-based suggestions.
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?
Gives clear context with 'Useful for consolidating fragmented playlists' and a concrete example ('Tech 2020' + 'Tech 2021'). However, it does not explicitly state when not to use it or mention alternative tools, so it falls short of full guideline coverage.
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 bears the responsibility for behavioral disclosure. It usefully adds a dependency on scan_inventory() and defines the report scope, but it does not explicitly state that the operation is read-only or describe side effects or error behavior. The report nature implies non-mutation but does not state it.
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: the first sentence states the core purpose, the second enumerates the report contents, and the third provides the prerequisite. There is no filler, redundancy, or unnecessary repetition of schema or annotation data.
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?
The description adequately covers purpose, report contents, and the required prior scan. An output schema exists, so return values need not be described. The only significant gap is parameter semantics, but given the minimal parameter surface and output schema, the overall context is strong.
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 the description never mentions the db_path parameter or its default/null behavior. With only one optional parameter, the description should have compensated by explaining what db_path means and how it affects the report, but it is completely absent.
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 opens with a specific verb and resource ('Generate a summary report from the inventory database') and explicitly lists the report contents (playlist/video counts, dead videos, duplicates, empty playlists). This clearly distinguishes it from the sibling find_* tools, which target individual issue types.
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 gives a clear prerequisite: 'Requires that scan_inventory() has been run first.' This provides strong contextual guidance for when to invoke the tool. It does not explicitly name alternatives or exclusion cases, but the prerequisite plus the summary-report purpose is sufficient for a 4.
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 only states the query action and the min_appearances default, but does not mention whether the operation is read-only, how db_path affects execution, whether any data is modified, or the grouping/ordering of results.
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 and front-loaded. The first sentence states the purpose, and the Args section succinctly documents the one non-obvious parameter with its default, 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?
For a simple two-parameter read query with an output schema, the description is mostly adequate, but the db_path parameter is entirely unexplained, and no context is given about the scope of the scan or any constraints. This leaves a notable gap for an agent deciding whether to supply db_path.
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 description adds meaningful semantics for min_appearances, explaining the minimum playlist count and the default value. However, db_path is never mentioned, and with 0% schema description coverage, its meaning remains opaque despite the schema's 'Db Path' title.
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 opens with the specific verb 'Find' and resource 'videos that appear in multiple playlists,' clearly identifying the duplicate-detection purpose. It also distinguishes itself from sibling tools like find_dead_videos and find_empty_playlists by focusing on cross-playlist duplicates.
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 clearly frames the tool's use case: detecting videos that appear in multiple playlists. It does not provide explicit when-not-to-use or alternative tool guidance, but the context is clear and no exclusions are needed for this focused query.
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 does disclose a useful precondition (scan_inventory if the database is empty), which adds context beyond the schema. But it does not explicitly state that the operation is read-only, or mention any other behavioral details such as formatting or side effects. The guidance is helpful but minimal.
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 two sentences long, with the first sentence directly stating the tool's purpose and the second adding an actionable tip. There is no filler or redundancy, and the most important information is front-loaded.
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?
The tool is simple and the output schema covers return values, but the description leaves gaps in parameter semantics and alternative selection. The scan_inventory precondition is useful, but an agent would still struggle to understand the purpose of db_path without additional documentation. For a tool with one parameter and multiple siblings, this is moderately complete but not fully sufficient.
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?
The schema coverage for the only parameter (db_path) is 0%, and the description does not mention this parameter at all. The parameter name is somewhat self-explanatory, and the description mentions 'inventory database', but it does not clarify whether db_path is optional or how it affects the query. The description fails to compensate for the lack of schema documentation.
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 function with a specific verb 'List' and a resource 'all playlists', and further specifies the scope as 'inventory database'. This sharply distinguishes it from sibling tools like get_playlist_contents (which lists contents) and find_empty_playlists (which filters playlists).
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 a concrete usage condition: 'Run scan_inventory() first if the database is empty.' This is genuine guidance for when to use the tool. However, it does not explicitly discuss alternatives or situations where the tool should not be used, so it falls short of a 5.
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?
No annotations are provided, so description carries the burden. It discloses API usage ('Uses the YouTube Data API') and quota cost ('~1,200 quota units'), which is useful behavioral context. It also states the scan scope (all playlists, all items, check video status), though it doesn't explain parameter effects.
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?
Four sentences total, front-loaded with the action and followed by usage and cost. No wasted words; each sentence adds value.
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?
Covers purpose, primary usage, and API cost, but lacks any parameter semantics and doesn't mention what db_path is for. With an output schema present, return details are covered, but the param gap makes it incomplete.
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 coverage is 0%, and description does not mention db_path or read_only. The tool's parameters are completely unexplained, leaving a significant gap.
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 uses a specific verb ('Run a full inventory scan') and resource (all playlists, all items, video status). It distinguishes itself as the primary data-collection command from siblings by stating 'Run this first before any curation operations.'
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?
Provides clear timing guidance: 'Run this first before any curation operations' and labels itself 'the primary data-collection command.' It does not explicitly mention when not to use it or alternatives, but this is clear enough for a first-step tool.
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, the description carries the full transparency burden. It discloses the critical safety behavior: 'By default runs in dry_run mode — set dry_run=False to actually remove.' This clearly distinguishes preview from execution. However, it does not elaborate on side effects of actual removal or the role of db_path.
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, front-loaded with the action statement, and each sentence earns its place. It efficiently explains the purpose, the dry_run behavior, and parameter details without extraneous content.
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?
The tool has an output schema (not shown), so return values need no explanation. The description covers the core purpose and dry_run, but omits any explanation of db_path, which is a parameter with a default. This leaves the description incomplete for a fully self-sufficient tool.
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 description adds meaning for the dry_run parameter, explaining it as 'If True (default), only preview; set False to execute.' However, db_path is completely unexplained, and schema description coverage is 0%. The description partially compensates but leaves a significant gap.
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 a specific verb and resource: 'Remove all dead/private/blocked videos from their playlists.' It distinguishes from sibling tools like find_dead_videos, as this tool performs removal rather than identification.
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 by explaining the dry_run default and how to execute, but it does not explicitly contrast with alternatives like find_dead_videos or state when this tool should be used over others. The guidance is implied rather than explicit.
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, the description carries full weight. It explicitly discloses that the source playlist is deleted after the move, that duplicates are skipped, and that dry_run defaults to True to prevent accidental execution. This is strong transparency, though it omits edge cases like source==target or missing playlists.
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 concise and well-structured: the core operation is stated in the first sentence, followed by key behaviors, then a clear args list. Every sentence adds value without unnecessary padding.
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 and the presence of an output schema, the description covers the main aspects: operation, duplicate handling, dry-run safety, and parameter meanings. It does not address db_path or error scenarios, but these are secondary to the core use case.
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?
Schema description coverage is 0%, so the description compensates well for three of four parameters: source_id and target_id are explained with format hints, and dry_run is clearly described including its default behavior. However, db_path is entirely undocumented in the description, leaving a gap for that 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 clearly states a specific action ('Move all videos from SOURCE playlist into TARGET, then delete SOURCE') and names the exact resources involved. It distinguishes itself from sibling tools like delete_playlist (which deletes without moving) and suggest_merges (which only suggests candidates).
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 when to use the tool but does not explicitly state alternatives or exclusions. It conveys the merge-and-delete workflow, making it easy to infer usage, but lacks direct guidance such as 'use this instead of delete_playlist when you want to preserve videos.'
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 of disclosure. It clearly reveals the destructive nature (deleting all contents) and the safety mechanism of dry-run mode. It stops short of detailing edge cases like non-existent playlists or idempotency, but the core behavioral traits are 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 economically written—two sentences plus a parameter list, all front-loaded with the core purpose. Every sentence contributes essential information: what it does, how to use it safely, and what the args mean. No filler.
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 delete operation with 3 parameters, the description covers the main functionality, the safety default, and the key parameters. An output schema exists so return values aren't needed in the description. The main shortfall is the unexplained db_path parameter, but the tool is otherwise adequately contextualized.
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 schema has 0% description coverage (no parameter descriptions), so the description must compensate. It does so for the two primary parameters: playlist_id (with example format) and dry_run (exact semantics of True/False). However, it omits any explanation for db_path, leaving a gap for that optional 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 opens with a clear, specific verb and resource: 'Delete a playlist and all its contents.' This distinctly identifies the operation and its scope, separating it from sibling tools like list_playlists or merge_playlists.
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 critical usage guidance by explaining the dry-run default and how to execute the deletion ('set dry_run=False to actually delete'). This tells the agent how to use the tool safely, though it doesn't explicitly contrast with alternatives or state when not to use it.
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:

[![yt-curator MCP server](https://glama.ai/mcp/servers/GeniusTechnoMystic/yt-curator/badges/card.svg)](https://glama.ai/mcp/servers/GeniusTechnoMystic/yt-curator)

Score Badge

Copy to your README.md:

[![yt-curator MCP server](https://glama.ai/mcp/servers/GeniusTechnoMystic/yt-curator/badges/score.svg)](https://glama.ai/mcp/servers/GeniusTechnoMystic/yt-curator)

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/GeniusTechnoMystic/yt-curator'

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