yt-dj-mcp
Syncs liked songs from YouTube Music, enriches them with DJ metadata (BPM, key, Camelot key, genre), and creates playlists from saved previews.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@yt-dj-mcpSync my liked songs and enrich 25 tracks with BPM and key"
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.
yt-dj-mcp
Local YouTube Music DJ crate MCP server.
The server syncs liked songs from YouTube Music, stores approximate DJ metadata such as BPM, key, Camelot key, and genre, then creates playlists only from saved previews.
Who This Is For
Use this if you have a large YouTube Music liked-song library and want a local, agent-friendly way to turn it into DJ crates. The workflow is deliberately preview-first: inspect candidates locally, then create playlists only after you approve a saved preview.
Related MCP server: navidrome-mcp
What It Can Do
Sync YouTube Music liked songs into local SQLite.
Analyze short local audio sections with
yt-dlp,ffmpeg, and Essentia.Store BPM, musical key, Camelot key, confidence, and source.
Search tracks by BPM/key/genre.
Save playlist previews before writing to YouTube Music.
Create YouTube Music playlists from reviewed previews.
Safety
Uses OAuth by default.
Stores secrets in
~/.config/yt-dj-mcp/.Never prints credential file contents.
Creates playlists only from saved previews.
Browser/HAR auth is an explicit fallback and stores session headers in
browser.json; keep it local and never commit it.Runtime state is local-only. Do not publish
library.sqlite, HAR files, browser headers, OAuth tokens, or downloaded audio.
Quick Start
git clone https://github.com/YOUR_USERNAME/yt-dj-mcp.git
cd yt-dj-mcp
python -m venv .venv
. .venv/bin/activate
pip install -e ".[dev,audio]"
pytest -qAdd the MCP server to your client:
[mcp_servers.yt_dj_mcp]
command = "/absolute/path/to/yt-dj-mcp/.venv/bin/yt-dj-mcp"
args = ["serve"]OAuth Setup
Create a Google Cloud OAuth client that can be used by ytmusicapi, then run:
yt-dj-mcp setup-auth
yt-dj-mcp auth-statusIf OAuth token creation succeeds but YouTube Music requests return HTTP 400, use the explicit local browser fallback:
ytmusicapi browser --file ~/.config/yt-dj-mcp/browser.json
chmod 600 ~/.config/yt-dj-mcp/browser.json
yt-dj-mcp auth-statusIf copying request headers from DevTools is unreliable, export a Chrome Network HAR and import it:
yt-dj-mcp import-har /path/to/music.youtube.com.har
yt-dj-mcp auth-statusbrowser.json contains browser session headers. Keep it local and never commit it.
Commands
yt-dj-mcp setup-auth
yt-dj-mcp auth-status
yt-dj-mcp import-har /path/to/music.youtube.com.har
yt-dj-mcp enrich-tracks --limit 25
yt-dj-mcp reset-auth
yt-dj-mcp serveMCP tools exposed by the server:
auth_statussetup_auth_instructionssync_liked_songslist_liked_songsenrich_tracksfind_dj_candidatescreate_playlist_previewget_playlist_previewcreate_youtube_music_playlistupdate_track_metadata
Audio Metadata Enrichment
enrich-tracks fills missing BPM/key/Camelot metadata by downloading a short
audio section with yt-dlp, analyzing it with Essentia, then caching the
analysis under ~/.config/yt-dj-mcp/audio-metadata-cache/.
Required local commands/packages:
ffmpeg -version
python -m yt_dlp --version
python -c "import essentia; print(essentia.__version__)"The command is best run in small batches:
yt-dj-mcp enrich-tracks --limit 10
yt-dj-mcp enrich-tracks --limit 50If yt-dlp or Essentia is missing, enrichment will leave tracks in the
missing count instead of crashing the server. Use this only for music you are
allowed to process locally; downloading streamed audio may be restricted by the
service's terms.
First Crate Workflow
Run
yt-dj-mcp setup-auth.Run
yt-dj-mcp auth-status.Add the MCP server to Codex or Claude.
Call
sync_liked_songs.Run
yt-dj-mcp enrich-tracks --limit 25or call MCPenrich_tracks.Call
find_dj_candidates.Call
create_playlist_preview.Review with
get_playlist_preview.Create the YouTube Music playlist with
create_youtube_music_playlist.
Suggested Agent Prompt
After installing the MCP server, try:
Sync my YouTube Music liked songs, enrich 50 tracks with BPM/key metadata, then
create 12-track DJ playlist previews grouped by compatible BPM and Camelot key.Review previews before asking the agent to create real YouTube Music playlists.
Limitations
BPM/key values are estimates. Use your ears before playing out.
YouTube Music auth can be brittle. OAuth is preferred, while browser/HAR auth is a local fallback when OAuth does not work.
Audio analysis depends on
ffmpeg,yt-dlp, and Essentia availability.This project does not manage playback and does not provide destructive library operations.
License
MIT
Available Tools
10 toolsauth_statusA
Check OAuth and connection status.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must disclose behavioral traits. Only states 'check' without mentioning read-only nature, side effects, or required permissions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single concise sentence with no redundant words. Perfectly front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Low complexity tool with no parameters, but no output schema or description of return format. Adequate for basic use, but could clarify what 'status' means in the response.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist; schema coverage is 100%. Baseline is 4 as per guidelines.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clear verb 'Check' and resource 'OAuth and connection status' precisely state the tool's purpose. No sibling tool performs this exact function, so no differentiation needed.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool or when alternatives might be better. For a simple status check, explicit usage hints are not critical but still absent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
create_playlist_previewC
Create a saved playlist preview.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | ||
| query | Yes | ||
| candidate_track_ids | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It indicates creation (a write operation) but provides no details about side effects, authentication needs, rate limits, or what happens to existing data. The behavior is 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise (one sentence), but it sacrifices substance for brevity. It front-loads the verb and resource but fails to provide necessary details. It is not verbose, but it is too terse to be effective.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (3 parameters, one nested object, no output schema) and lack of annotations, the description is completely inadequate. It does not explain the tool's behavior, return values, or parameter meanings, leaving the agent with insufficient context to use the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, meaning the schema itself provides no parameter descriptions. The description adds no information about parameters, such as what 'query' object structure should be or the meaning of 'candidate_track_ids'. The agent must guess parameter semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a verb ('Create') and a resource ('playlist preview'), which provides a basic purpose. However, it is vague because it does not clarify what a 'saved playlist preview' is or how it differs from siblings like 'get_playlist_preview'. It is not a tautology but lacks specificity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No usage guidelines are provided. The description does not indicate when to use this tool versus alternatives such as 'get_playlist_preview' or 'create_youtube_music_playlist'. There are no prerequisites, context, or exclusions mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
create_youtube_music_playlistD
Create a YouTube Music playlist from a preview.
| Name | Required | Description | Default |
|---|---|---|---|
| preview_id | Yes | ||
| description | No | ||
| playlist_name | Yes | ||
| privacy_status | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, and the description fails to disclose behavioral traits such as mutability, side effects, required permissions, or idempotency. The agent cannot understand the implications of invoking this tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely short (one sentence), but this brevity sacrifices essential information. It is under-specified rather than concise, missing critical details needed for correct invocation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 4 parameters, no output schema, and no annotations, the description is woefully incomplete. The agent lacks enough context to use the tool effectively, especially given the absence of parameter explanations or behavioral hints.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, and the description adds no meaning beyond the parameter names. 'preview_id,' 'playlist_name,' 'description,' and 'privacy_status' are not explained, leaving the agent uncertain about valid values or formats.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'Create a YouTube Music playlist from a preview,' which clearly identifies the action (create) and resource (playlist). However, 'from a preview' is vague and does not differentiate from sibling tools like 'create_playlist_preview,' which may have overlapping functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives, such as 'create_playlist_preview' or other creation tools. No prerequisites or context (e.g., authentication, existence of preview) are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
enrich_tracksC
Enrich local tracks with DJ metadata.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| only_missing | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must disclose behavioral traits. It does not explain what 'enrich' entails (e.g., network calls, local modifications, required permissions), leaving critical behavioral aspects opaque.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, which is concise but overly terse. It lacks structure and fails to convey essential information, sacrificing clarity for brevity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the absence of output schema and annotations, the description is severely incomplete. It does not explain return values, side effects, or parameter usage, making it nearly useless for an agent to correctly invoke the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, meaning the schema provides no parameter descriptions. The tool description does not mention or clarify the purpose of the two parameters (limit, only_missing), failing to add any value beyond the raw schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description states verb 'enrich' and resource 'local tracks with DJ metadata', giving a general idea of the tool's function. However, 'enrich' is not a standard operation and lacks specificity, and the description does not distinguish it from sibling tools like update_track_metadata.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The description does not mention prerequisites, context, or exclusions, leaving the agent without decision support.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
find_dj_candidatesC
Find DJ playlist candidates by BPM/key/genre.
| Name | Required | Description | Default |
|---|---|---|---|
| key | No | ||
| genre | No | ||
| limit | No | ||
| bpm_max | No | ||
| bpm_min | No | ||
| camelot_key | No | ||
| include_missing_metadata | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description lacks detail on behavior such as how results are ranked, whether it searches personal or global catalog, or how parameters interact. With no annotations, the description should provide more transparency but is minimal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence, which is concise, but it is under-specified for a tool with 7 parameters. It lacks structure and fails to earn its place by conveying necessary information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (7 parameters, no annotations, no output schema), the description is critically incomplete. It does not explain return values, prerequisites, or parameter usage, leaving the agent underinformed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, meaning the description must explain parameters. It mentions BPM/key/genre but does not clarify which schema properties correspond, nor does it explain camelot_key, limit, include_missing_metadata, or bpm_min/max semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool finds DJ playlist candidates by BPM/key/genre, which is a specific action and resource. It distinguishes from sibling tools like auth_status or list_liked_songs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit when-to-use or when-not-to-use guidance is provided. The description implies usage for music discovery based on musical parameters, but does not address alternatives or context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_playlist_previewC
Get a saved playlist preview.
| Name | Required | Description | Default |
|---|---|---|---|
| preview_id | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description must disclose behavior. It implies a read operation ('Get'), but lacks details such as whether authentication is needed, what data is returned, or if there are any side effects. Basic transparency is present but insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise and front-loaded, which is good for quick scanning. However, it lacks any structural elements (e.g., notes, examples) that could enhance understanding without adding much length.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with one required parameter and no output schema, the description covers the basic action but fails to explain what a playlist preview is, how it relates to create_playlist_preview, or what the return value looks like. This leaves an agent needing further inference.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description should compensate but does not. The single parameter 'preview_id' is self-explanatory by naming, but the description adds no extra meaning, format, or constraints beyond what the schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a clear verb 'Get' and resource 'playlist preview', but does not specify what a preview is or distinguish it from sibling tools like create_playlist_preview or enrich_tracks. It is a minimal statement that leaves room for ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, when-not-to-use, or relationships to sibling tools like create_playlist_preview.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_liked_songsC
List local liked songs.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| offset | No | ||
| metadata_status | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, and the description only says 'List', implying read-only but not stating it explicitly. No mention of authentication, rate limits, or side effects. Fails to disclose behavior beyond the basic action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Very concise (4 words) but at the expense of essential information. Under-specification rather than efficient conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No annotations, no output schema, undocumented parameters, and no differentiation from sibling tools. Extremely incomplete for any practical use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not mention any of the three parameters (limit, offset, metadata_status). Leaves the agent guessing about their semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'List local liked songs' which clearly specifies the verb (list) and resource (local liked songs). However, 'local' could be ambiguous and no differentiation from siblings like sync_liked_songs or get_playlist_preview.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs alternatives like sync_liked_songs or enrich_tracks. No hints about prerequisites or context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
setup_auth_instructionsA
Show CLI OAuth setup instructions.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, and the description does not disclose any behavioral traits beyond showing instructions. No mention of side effects, auth requirements, or execution context. As no annotations exist, the description carries full burden and is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One short sentence, front-loaded with key action and resource. No unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Adequate for a parameterless tool, but does not specify which CLI or service context. With no output schema, return value is implied but not stated. Minimal completeness for low complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist, so schema coverage is 100%. The description adds no parameter information, but this is acceptable given zero parameters. Baseline of 3 adjusted upward due to no missing semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses specific verb 'Show' and resource 'CLI OAuth setup instructions', clearly stating what the tool does. It distinguishes from sibling 'auth_status' which checks authentication status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use versus alternatives, but the simple nature of the tool implies usage when needing to display setup instructions. Lacks mention of when not to use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
sync_liked_songsC
Sync liked songs into local SQLite.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description bears full burden for behavioral disclosure. It only states the basic action, omitting details on whether it creates or updates records, if it requires authentication, or if it modifies remote data. The word 'sync' implies data transfer but no safety or side effects are described.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short but lacks necessary details. It is under-specified rather than concise. A concise description would still convey essential parameters and usage context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has one parameter, no output schema, and no annotations, the description is incomplete. It does not explain what sync does, how limit affects behavior, what the return value is, or error conditions. The sibling tools suggest related operations but no cross-references.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0% and the description provides zero information about the single parameter 'limit'. The agent cannot infer its purpose (e.g., number of songs to sync) from the tool description alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Sync liked songs into local SQLite' clearly states the action (sync) and resource (liked songs, local SQLite). It distinguishes from sibling 'list_liked_songs' which only retrieves. However, the verb 'sync' is somewhat ambiguous without specifying directionality or whether it's incremental.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like 'list_liked_songs' or 'enrich_tracks'. The description does not mention prerequisites, expected state, or scenarios where sync is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
update_track_metadataC
Manually override DJ metadata for a track.
| Name | Required | Description | Default |
|---|---|---|---|
| bpm | No | ||
| genre | No | ||
| notes | No | ||
| track_id | Yes | ||
| camelot_key | No | ||
| musical_key | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It states 'override' indicating a write operation but fails to explain whether it replaces all fields or only provided ones, required permissions, or potential side effects (e.g., irreversible changes).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no wasted words, but its brevity sacrifices necessary detail. It is appropriately front-loaded but under-informative for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 6 parameters, 0% schema coverage, no annotations, and no output schema, the description is grossly incomplete. It lacks any information about return values, validation, or behavior with partial updates, rendering it insufficient for reliable tool selection and use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides zero parameter information despite 0% schema coverage. It does not explain the purpose or format of fields like bpm, genre, camelot_key, etc., leaving the agent without critical context for invocation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific verb ('override') and resource ('DJ metadata for a track'), distinguishing it from sibling tools like enrich_tracks which likely automate metadata updates. It effectively communicates the manual nature of this operation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for manual overrides but does not explicitly state when to use versus alternatives like enrich_tracks. No guidance on prerequisites or conditions is given, 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.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
10 tool updates
v0.1.0- First observed
auth_status - First observed
create_playlist_preview - First observed
create_youtube_music_playlist - First observed
enrich_tracks - First observed
find_dj_candidates - First observed
get_playlist_preview - First observed
list_liked_songs - First observed
setup_auth_instructions - First observed
sync_liked_songs - First observed
update_track_metadata
TDQS
Scored across 10 tools
Most tools have distinct purposes (auth, syncing, playlist creation, metadata enrichment). Some overlap exists between create_playlist_preview and create_youtube_music_playlist, but they target different artifacts (local preview vs. YouTube Music playlist).
Most tools follow a verb_noun pattern (e.g., enrich_tracks, sync_liked_songs). However, auth_status and setup_auth_instructions deviate slightly, and some names are multi-word nouns. Overall consistent and readable.
10 tools is well-scoped for a server integrating YouTube Music, local SQLite, and DJ metadata. Each tool addresses a core function without unnecessary bloating.
Covers essential workflows: auth, syncing, playlist preview/creation, metadata enrichment, and candidate finding. Minor gaps like missing playlist deletion or track removal, but main DJ tasks are supported.
Maintenance
Related MCP Connectors
Accurate anime-song (anison) database for AI-built playlists — export to Spotify/Apple/YT Music
Audio features + harmonic set-building for tracks by name/ISRC. Spotify audio-features replacement.
Identify the tracklist of any DJ mix from its YouTube, SoundCloud or Mixcloud URL.
YouTube discovery, transcripts, library search, and monitors with API keys or OAuth.
1
Related MCP Servers
- FlicenseNot gradedqualityBmaintenanceEnables managing YouTube Music playlists and searching songs via the YouTube Data API v3, deployed as a free Cloudflare Worker.-
- AlicenseAqualityBmaintenanceEnables building mood-based playlists for Navidrome by joining your library, listen history, and personal playlist labels from Navidrome, ListenBrainz, and Last.fm.1549 npmAGPL 3.0
- AlicenseAqualityBmaintenanceEnables AI assistants to control Spotify playback, manage playlists, and plan DJ sets using BPM, key, and energy data.37MIT
- AlicenseNot gradedqualityBmaintenanceEnables DJs to retrieve BPM, key/Camelot, energy, and other track metadata with provider provenance, score transitions, plan setlists, and control Spotify playlists and playback with staged, revalidated writes for safety.MIT