navigravity
NaviGravity (Navidrome Agentic Curator) 🎧
NaviGravity (NG) is an intelligent MCP (Model Context Protocol) server that empowers an AI agent to act as a sophisticated music curator for your self-hosted Navidrome library.
Unlike simple search tools, NG implements a specific curation philosophy focused on quality, discovery, and non-destructive library management.
🧠 Core Philosophy
The "Bliss" Quality Gate: The AI acts as a critic. No playlist is created without passing a
assess_playlist_qualitycheck to ensure diversity and prevent artist repetition.Virtual Tags (Non-Invasive): We treat your audio files as sacred read-only artifacts. Moods and custom tags are stored as "System Playlists" (e.g.,
System:Mood:Focus), keeping your file metadata clean.Smart Discovery: Features "Magic List" algorithms to surface Forgotten Gems, Hidden Tracks, and divergent genres to break your filter bubble.
Related MCP server: Discogs MCP Server
🤖 For Agents & Curators
We provide a specialized guide for the Large Language Models interacting with this toolset. It defines the "Curator Persona", "Bliss Quality Gate" protocols, and strategic patterns (e.g., The Time Machine or Semantic Exploration).
👉 Read the LLM Tool Usage Manifesto
Setup & Installation
Prerequisites:
Python 3.10+
A running Navidrome server and user account
Clone the repository:
git clone <repository_url> cd navigravityCreate and activate a Python virtual environment:
python3 -m venv .venv source .venv/bin/activateInstall dependencies:
pip install .Configuration: Copy
.env.exampleto.env(create one if needed) and set your Navidrome credentials:NAVIDROME_URL=http://your-navidrome-instance:4533 NAVIDROME_USER=your_username NAVIDROME_PASS=your_passwordLogging Configuration (Optional): By default, logs are output to
stderr(visible in MCP Client logs). To save logs to a file:NAVIDROME_LOG_FILE=./logs/navidrome_mcp.log
🚀 Usage
Important: This is an MCP server. It runs strictly as a backend process for an AI Client (like Antigravity, Claude Desktop or Zed). You do NOT need to "visit" it in a browser.
For a deep dive into how strict coordination works without a UI, see MCP Architecture & Workflow.
Running via MCP Client (Recommended)
Add the following to your client's configuration (e.g., claude_desktop_config.json):
{
"mcpServers": {
"navidrome": {
"command": "/path/to/navigravity/.venv/bin/python",
"args": ["/path/to/navigravity/src/navidrome_mcp_server.py"]
}
}
}🛠 Troubleshooting & Local Debugging
If you encounter ModuleNotFoundError or errors spawning the process, ensure you are pointing to the Python executable inside your virtual environment.
To test the server manually and explore tools with a UI, use the MCP Inspector:
# From the project root
npx @modelcontextprotocol/inspector .venv/bin/python src/navidrome_mcp_server.pyThis will open a browser interface at http://localhost:6274 allowing you to interact with all tools.
🧰 Available Tools
The agent has access to the following tools:
Unified Analysis:
analyze_library(mode): One tool to rule them all.mode='composition': Genre distribution & library stats (Cold Analysis).mode='pillars': Identifies canonical artists by album count.mode='taste_profile': Analyzes recent/frequent/starred for user habits.
batch_check_library_presence: Verification tool to find gaps (Missing Music) in bulk.
Discovery & Recommendation:
get_smart_candidates(mode): Statistical discovery engine.Smart Selection: Automatically ranks candidates by
smart_score(Neutral=3, Stars=+1, Heart=+5).Modes:
rediscover,hidden_gems,unheard_favorites,lowest_rated,divergent(breaks filter bubble).
get_similar_artists: Finds relational bridges. Automatically falls back to "Genre Peers" if canonical data is missing.get_similar_songs: "Radio Mode" for finding sonically resonant tracks.get_genres/explore_genre: Deep dive into specific genres.get_genre_tracks: Fetches random tracks from a genre.search_music_enriched(query, artist?, album?): Robust metadata-rich search with multi-strategy fallback. Resolves compound queries (e.g.,"Daft Punk Discovery","Miles Davis Bitches Brew") via album expansion, unicode normalization, and client-side post-filtering. Optionalartistandalbumparameters for precise filtering.
Curation & Management:
manage_playlist(name, operation, track_ids):Create/Replace customized playlists.
Mood Convention: Use
NG:Mood:{MoodName}(e.g.,NG:Mood:Focus) to create virtual mood tags.
assess_playlist_quality: The "Bliss" check logic. Includes automatic ID Sanitization (stripping quotes/backticks).
📜 License & Contributing
This project is open-source under the MIT License.
Want to help? Check out CONTRIBUTING.md for our Beta Testing Guide, Developer Instructions, and Social Contract.
This project depends on libraries likepy-sonic which are licensed under GPLv3. While our code is MIT, bundling it with GPL dependencies may affect the licensing of distributed binaries.
Built with ❤️ for the self-hosted music community.
Available Tools
15 toolsanalyze_libraryA
Analyzes the library inventory and user stats.
Args: mode: The type of analysis to perform. - 'composition': Returns genre distribution and total stats (Cold Analysis). - 'pillars': Identifies core artists (Album Count) (Canonical Analysis). - 'taste_profile': Analyzes recent/frequent/starred for top artists & eras (Warm Analysis).
| Name | Required | Description | Default |
|---|---|---|---|
| mode | No | composition |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It transparently describes the outputs for each mode (e.g., genre distribution, core artists, taste profile). However, it does not mention any side effects, permissions, or limitations, though the tool appears read-only.
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 concise, with only two short paragraphs. It front-loads the purpose and then clearly lists the parameter and its options. No extraneous content.
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 an output schema, the description does not need to detail return values. It adequately covers the input parameter and the three modes. The context signals indicate low complexity, and the description is complete for proper invocation.
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 input schema provides no descriptions for the 'mode' parameter (0% coverage). The description adds full semantics by enumerating the three allowed values and explaining what each returns, which is essential for the agent to use the parameter correctly.
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's purpose: 'Analyzes the library inventory and user stats.' It lists specific analysis modes (composition, pillars, taste_profile), distinguishing it from sibling tools that focus on playlists, genres, or search.
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 explains the different modes of analysis but does not explicitly state when to use this tool versus alternatives like assess_playlist_quality or explore_genre. Usage context is implied by the library analysis focus, but no exclusions or guidance are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
assess_playlist_qualityC
(Bliss) Checks diversity and repetition.
| Name | Required | Description | Default |
|---|---|---|---|
| song_ids | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden for behavioral disclosure, but it only says 'checks diversity and repetition.' It does not state whether the tool is read-only, requires special permissions, has rate limits, or what output to expect. The agent cannot infer safety or 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short, but conciseness should not sacrifice essential information. Every sentence is present, but the content is insufficient for effective usage. It suffers from under-specification rather than being appropriately concise.
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?
Despite having an output schema (so return values need not be described), the description omits critical details: what diversity metrics are used, how repetition is measured, any constraints on input size, and what the output represents. The tool is inadequately documented for an AI agent to use 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%, so the description must compensate, but it adds nothing about the single parameter 'song_ids.' The agent is left guessing what IDs are expected (Spotify URIs, internal IDs, count limits, etc.) and how they relate to the tool's purpose.
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 it 'checks diversity and repetition,' which is a specific verb and resource. This distinguishes it from sibling tools like 'analyze_library' (broader analysis) or 'manage_playlist' (modification). However, the prefix '(Bliss)' is unclear and adds no value, and the description is overly brief.
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. For example, there is no mention of prerequisites, scenarios (e.g., assess a playlist before sharing), or what differentiates it from 'get_smart_candidates' or 'validate_playlist_rules'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
batch_check_library_presenceB
Checks if artists/albums exist in the library. Input example: [{"artist": "Camel"}, {"artist": "Pink Floyd", "album": "Animals"}]
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden for behavioral disclosure. It only states the tool 'checks if artists/albums exist' without describing output format, performance constraints, or side effects. The example only shows input, not behavior.
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: two sentences (purpose + example). It is front-loaded with the essential action. Every word adds value.
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 complex parameter and an output schema exists, the description does not need to detail return values. However, it lacks any mention of the output structure (e.g., boolean results), relying on the output schema. This is acceptable but could be slightly more explicit.
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%, so the description must compensate. The input example adds meaning by showing the expected array structure with 'artist' and 'album' keys. However, it does not fully explain all possible properties or that any key is allowed per the 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?
The description clearly states the verb 'checks' and the resource 'artists/albums exist in the library'. It also provides an input example to clarify the batch nature. It distinguishes well from sibling tools like get_similar_artists or search_music_enriched.
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 provides no guidance on when to use this tool versus alternatives. There is no mention of when not to use it or any prerequisites. The agent is left to infer usage from the tool name and purpose.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
check_connectionA
Verifies connection to the backend Navidrome instance.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
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 'Verifies connection,' which implies a read-only, non-destructive operation, but it does not disclose any behavioral details like error handling, latency, or side effects. The description is adequate for a simple health check but lacks depth.
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 concise sentence that is front-loaded with the key action and target. Every word serves a purpose, with no unnecessary 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?
Although the tool has no parameters and an output schema exists, the description does not mention what the output looks like or what constitutes a successful/failed connection. For a simple health check, this is adequate but could be improved by noting that it returns a status indicator.
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 input schema has zero parameters, so the description does not need to compensate for parameter documentation. As per guidelines, baseline score is 4 for tools with no parameters. The description does not add parameter semantics, which is acceptable.
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's purpose: 'Verifies connection to the backend Navidrome instance.' It uses a specific verb ('Verifies') and resource ('connection to the backend Navidrome instance'), which distinguishes it from sibling tools that focus on analysis, search, or playlist management.
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 context but does not provide explicit guidance on when to use this tool versus alternatives. It is clear that it is for verifying connectivity, but there is no mention of prerequisites, when not to use it, or references to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
explore_genreC
Gets detailed metrics for a genre (Top Artists, Album counts).
| Name | Required | Description | Default |
|---|---|---|---|
| genre | Yes | ||
| limit | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
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 only states the action and gives examples of returned data. It does not mention whether the operation is read-only, rate limits, authentication needs, or error behavior (e.g., handling non-existent genres). The existence of an output schema partially compensates but the description itself is lacking.
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 that front-loads the main action and key examples. There is no verbosity or redundancy. Every word earns its place, making it highly efficient for an agent to parse.
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 2 parameters, an output schema, and multiple sibling tools, the description is too sparse. It does not clarify what 'detailed metrics' includes beyond the two examples, nor how 'limit' interacts with the output. It also fails to differentiate from other genre-related tools, leaving the agent to guess usage context.
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%, so the description must clarify parameter meaning. It mentions 'Top Artists, Album counts' but does not explain how the 'limit' parameter affects these metrics (e.g., limit on top artists, albums, or total results). The 'genre' parameter is self-explanatory, but the description adds minimal semantic value overall.
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 it retrieves detailed metrics for a genre, specifying examples like Top Artists and Album counts. This is a specific verb+resource. However, it doesn't explicitly distinguish from sibling tools such as get_genres or get_genre_tracks, leaving some ambiguity about the exact scope of 'detailed metrics'.
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 like get_genres or get_genre_tracks. There is no mention of prerequisites, exclusion criteria, or context where this tool is preferred. The description is insufficient for an agent to decide confidently.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_genresA
Lists all available genres with track and album counts.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It accurately describes the read-only list operation but does not disclose potential behavior like pagination or data limitations. It is adequate but lacks depth.
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, short sentence that conveys the entire purpose. No filler or repetition; every word earns its place.
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 simplicity of the tool (no params, output schema exists), the description is mostly complete. It could mention the data scope or whether all genres are included, but it is sufficient for the agent.
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 tool has zero parameters and schema description coverage is 100%, so the description naturally adds no parameter info. Per guidelines, baseline is 4 for 0 params.
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 specific verb 'Lists' and resource 'genres', and specifies the output includes track and album counts. It clearly states what the tool does and differentiates from sibling tools like get_genre_tracks.
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 explore_genre or get_genre_tracks. The description lacks any context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_genre_tracksC
Fetches random tracks for specific genre(s). Accepts a single string or a list of strings.
| Name | Required | Description | Default |
|---|---|---|---|
| genre | Yes | ||
| limit | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must cover behavior. It states 'random tracks' but does not explain randomness details, number of tracks returned, error handling for invalid genres, or whether the tool is read-only. This is insufficient for an agent to understand behavioral implications.
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 with two short sentences, front-loading the purpose and key input format. Every word serves a purpose with no redundancy.
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?
Despite an output schema existing, the description fails to cover essential behavioral aspects like randomness, limit handling, and error scenarios. For a tool with two parameters and no annotations, this is incomplete.
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 adds value by clarifying that the 'genre' parameter accepts a single string or list of strings. However, it does not explain the 'limit' parameter's purpose or constraints, leaving gaps.
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 that the tool fetches random tracks for specific genre(s), using the verb 'fetches' and the resource 'random tracks for specific genre(s)'. It distinguishes from siblings like 'explore_genre' and 'get_genres' by specifying its unique function.
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 over alternatives like 'search_music_enriched' or 'get_smart_candidates'. It only mentions input format but does not specify use cases or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_similar_artistsA
Gets similar artists. Provide artist_id OR artist_name (name will be resolved to ID first). Uses getArtistInfo2 as a reliable fallback for library similarity.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| artist_id | No | ||
| artist_name | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses fallback behavior and name resolution but does not address authentication needs, rate limits, or what happens on missing data.
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?
Two sentences, front-loaded with purpose, no wasted words. Could be slightly more structured to separate input and behavior.
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?
Output schema exists so return values need not be explained, but limit parameter is not described, and no guidance on error scenarios or defaults beyond schema. Adequate but incomplete.
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%. The description adds meaning for artist_id and artist_name (alternatives, resolution) but does not explain the limit parameter, leaving it under-described.
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 'Gets similar artists' and specifies the two input options (artist_id or artist_name) with resolution behavior. This distinguishes it from sibling tools like get_similar_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?
The description explains how to provide input (artist_id OR artist_name) and mentions a fallback, but lacks explicit guidance on when not to use this tool versus alternatives like explore_genre or get_similar_songs.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_similar_songsC
Gets similar songs to the target song (Radio Mode).
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | ||
| song_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | 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 only states a read operation, but fails to mention what 'similar' means algorithmically, output format (despite output schema existing), or any limitations (e.g., required authentication).
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 waste. It front-loads the verb and resource. However, additional context could be added without losing 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?
Given the tool's simplicity (2 params, output schema exists), the description is minimally adequate. It fails to mention that the output is a list of songs or any prerequisites. Satisfies basic purpose but leaves gaps for complex scenarios.
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 input schema has 0% description coverage, yet the description adds no explanation for the parameters. While 'song_id' and 'limit' are self-explanatory, the description does not clarify identifier format or limit's effect on results.
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 gets similar songs to a target song, with 'Radio Mode' providing context. It implies differentiation from get_similar_artists, but does not explicitly distinguish the similarity criteria.
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 given on when to use this tool versus alternatives like get_similar_artists or search_by_tag. The 'Radio Mode' hint is too vague to constitute explicit usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_smart_candidatesA
Generates lists based on stats with advanced filtering.
Args: mode: recently_added, most_played, top_rated, lowest_rated, rediscover, rediscover_deep, hidden_gems, unheard_favorites, divergent, fallen_pillars, similar_to_starred. Accepts comma-separated list of modes. limit: Max tracks to return (default 50) include_genres: List of genres to strictly include (case-insensitive partial match) exclude_genres: List of genres to exclude min_bpm: Minimum BPM max_bpm: Maximum BPM mood: 'relax', 'energy', 'focus', etc. max_tracks_per_artist: Diversity constraint reference_track_ids: List of source track IDs to use as seeds (Similarity expansion)
| Name | Required | Description | Default |
|---|---|---|---|
| mode | Yes | ||
| mood | No | ||
| limit | No | ||
| max_bpm | No | ||
| min_bpm | No | ||
| exclude_genres | No | ||
| include_genres | No | ||
| reference_track_ids | No | ||
| max_tracks_per_artist | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose any behavioral traits such as mutability, authorization needs, rate limits, or side effects. The term 'generates' suggests a read-only operation, but this is implicit. For a tool with no annotations, the description should explicitly state such traits.
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 front-loaded with a clear purpose sentence, followed by a structured 'Args' list. Each parameter is explained concisely. Minor redundancy (e.g., 'Mood: relax, energy, focus, etc.' could be more specific) but overall efficient.
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 (9 parameters, output schema exists), the description covers the purpose and all parameters adequately. It does not explain return values, but the output schema handles that. Missing details like rate limits or prerequisites are minor gaps.
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%, so the description carries the full burden of explaining parameters. It provides clear explanations for all 9 parameters, including possible values for mode, default values, and usage notes (e.g., case-insensitive partial match for genres). This significantly exceeds baseline expectations.
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 generates lists based on stats with advanced filtering, covering multiple modes and filter options. This distinguishes it from sibling tools like search_by_tag or get_similar_songs, which have different scopes.
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 this tool versus alternatives. While the description implies it's for generating smart candidates based on stats, it doesn't specify exclusions or context. Sibling tools like analyze_library or validate_playlist_rules could overlap; the lack of comparative cues lowers the score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_playlistsA
Lists all available playlists with IDs for discoverability.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, description carries full burden. It clearly states a read-only operation retrieving all playlists and IDs, implying no side effects. Does not detail auth or pagination, but sufficient for a simple listing.
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 sentence conveys purpose and scope without waste. Every word earns its place.
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?
Despite no annotations and zero parameters, description is complete for a simple listing tool. Output schema provides return details, so description need not elaborate.
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 100%), so description adds no param info. Baseline is 4 for zero parameters; no further elaboration needed.
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 uses specific verb ('Lists') and resource ('all available playlists'), clearly differentiating from sibling tools like manage_playlist (which modifies) and assess_playlist_quality (which analyses).
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 phrase 'for discoverability' implies usage context but no explicit when-to-use or when-not-to-use compared to alternatives. Lacks guidance on exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
manage_playlistA
Manages playlists and moods.
Args: name: Playlist name. For moods, use convention 'NG:Mood:{MoodName}'. operation: - 'create': Replaces/Creates playlist with track_ids. - 'append': Adds track_ids to playlist (creates if missing). - 'get': Returns tracks in playlist. track_ids: List of track IDs (required for create/append).
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | ||
| operation | No | get | |
| track_ids | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description carries the full burden. It discloses that 'create' replaces/creates, 'append' adds (creates if missing), and 'get' returns tracks. However, it omits side effects like overwrite behavior, limits, or authentication requirements.
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 well-structured with headings and bullet points, front-loading key information. It is concise but could be slightly more streamlined.
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 low complexity, 3 parameters, and existence of an output schema, the description covers the essential behavior. It explains operations and parameter usage thoroughly, though it could mention the output format for 'get'.
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%, but the description adds detailed meaning for all three parameters: naming convention for moods, operation types with behaviors, and track_ids required for create/append. This fully compensates for the lack of schema descriptions.
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 'Manages playlists and moods' and details three operations (create, append, get), making the purpose clear. However, the verb 'manages' is slightly vague and does not explicitly differentiate from sibling tools like 'list_playlists' or 'assess_playlist_quality'.
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 this tool versus alternatives. The description implies usage for creating, appending, or getting tracks, but lacks exclusions or context for specific scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_by_tagC
Multi-genre intersection/union for 'vibe' search.
| Name | Required | Description | Default |
|---|---|---|---|
| tags | Yes | ||
| logic | No | OR |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided. The description does not disclose side effects, data mutation, rate limits, or other behavioral traits. For a search tool, it fails to clarify if it is read-only or modifies state.
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?
Extremely short (one sentence), but lacks critical details, making it under-specified rather than concise. Every sentence should add value; this one is too vague.
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?
Despite having an output schema (unknown content), the description is incomplete. It does not explain the search domain, result types, or how to use the tool effectively. Contextual gaps remain.
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%, but the description adds meaning by explaining 'intersection/union' which clarifies the 'logic' parameter. However, it does not explain the 'tags' parameter structure or expected values beyond the 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 mentions 'Multi-genre intersection/union for vibe search', indicating it searches by tags with logical operators. However, it does not specify the resource being searched (e.g., tracks, artists) nor a clear verb, leaving 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 on when to use this tool versus siblings like 'search_music_enriched' or 'get_similar_songs'. The description lacks context for appropriate use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_music_enrichedA
Robust search with multi-strategy fallback. Returns enriched track metadata.
WHEN to use optional parameters:
artist: provide when you know the artist name (e.g., artist='Miles Davis'). Results are post-filtered so only tracks from this artist are returned.album: provide when you know the album name (e.g., album='Bitches Brew'). Results are post-filtered on the song's album field — NOT the track title.
Search strategy (cascading, stops at first successful step):
search3(query, songCount=limit*3, albumCount=2) → if songs found: post-filter by artist/album, return. → if only albums found: expand each album into tracks (max 2), post-filter, return.
[only if
artistprovided] search3(artist) → post-filter by album.[only if
albumprovided] search3(album, albumCount=5) → expand albums → return tracks.Unicode normalization fallback: retry step 1 with NFKD-normalized query (only if normalized query differs from original).
Raw fallback: return step-1 results as-is (never returns empty if tracks exist).
| Name | Required | Description | Default |
|---|---|---|---|
| album | No | ||
| limit | No | ||
| query | Yes | ||
| artist | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description fully discloses the complex cascading search strategy, post-filtering behavior, Unicode normalization fallback, and raw fallback. It is highly transparent about all behavioral traits.
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 well-structured with sections for parameter guidance and a bulleted list of search steps. It is fairly long but each part contributes necessary detail; slight trimming could improve 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?
Given the tool's complexity (multi-strategy fallback, 4 parameters), 0% schema description coverage, and the presence of an output schema, the description covers all essential aspects: search strategy, parameter effects, fallback logic, and edge cases like Unicode normalization.
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%, but the description compensates by explaining the purpose and behavior of 'artist' and 'album' parameters. The 'query' parameter is implied, while 'limit' is only mentioned in the strategy (limit*3) but not fully explained.
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 'Robust search with multi-strategy fallback. Returns enriched track metadata.' This provides a specific verb (search) and resource (track metadata) while distinguishing from sibling tools like search_by_tag or get_genre_tracks.
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 explicitly explains when to use the optional 'artist' and 'album' parameters and how they post-filter results. However, it does not explicitly advise when to choose this tool over alternatives among sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
validate_playlist_rulesC
Dry-run validation for diversity and mood. Example rules: {"max_tracks_per_artist": 2, "exclude_genres": ["Metal"], "min_bpm": 100}
| Name | Required | Description | Default |
|---|---|---|---|
| rules | Yes | ||
| track_ids | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It implies a non-destructive dry-run via 'Dry-run validation', but lacks details on authentication, rate limits, side effects, or what happens with invalid inputs. More behavioral context is needed.
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 exceptionally concise: one sentence and an example. Every element is purposeful and front-loaded, with no unnecessary verbiage.
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 an output schema, required freeform object, and sibling tools with overlapping domains, the description is too sparse. It omits explanation of the return value, exact semantics of the rules, and what constitutes valid track_ids. More completeness is needed for effective 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%, so the description must compensate. The example 'rules' object provides concrete values, adding meaning to the freeform parameter. However, 'track_ids' remains completely undescribed, leaving ambiguity about expected format or constraints.
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 identifies the tool as a dry-run validation for playlist rules, specifying verb and resource. The example hints at diversity and mood constraints, distinguishing it from sibling tools like assess_playlist_quality or analyze_library. However, it could be more explicit about what 'diversity and mood' specifically entail.
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 provides no guidance on when to use this tool versus alternatives, such as analyze_library or assess_playlist_quality. There is no mention of prerequisites, context, or situations where this tool should be preferred or avoided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TDQS
Each tool has a clearly distinct purpose, ranging from library analysis and playlist management to similarity and search. No two tools overlap significantly; even similar sounding tools like search_by_tag and search_music_enriched serve different search strategies.
All tool names follow a consistent verb_noun pattern in snake_case, such as analyze_library, get_similar_artists, and manage_playlist. The verbs are descriptive and align with the actions, making the set predictable.
With 15 tools, the set is well-scoped for a music library assistant, covering analysis, search, playlist management, and similarity. The count is sufficient without being overwhelming.
The tool surface covers core operations like library analysis, playlist CRUD, search, and similarity. Minor gaps exist, such as missing explicit delete for playlists or detailed artist/album retrieval, but these are not critical for the intended curation use case.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
MCP server for Producer/Riffusion AI music generation
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Capability registry for the agentic economy. Semantic search over verified MCP server listings.
MCP server for AI agents to plan, verify, and deploy Cloudflare-native apps.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAn MCP server that gives AI agents the ability to listen to and understand music/audio files, enabling semantic analysis, stem separation, lyrics transcription, and signal processing via tool calls.1MIT
- AlicenseNot gradedqualityAmaintenanceA powerful Model Context Protocol (MCP) server that enables AI assistants to interact with your personal Discogs music collection.1516MIT
- FlicenseNot gradedqualityDmaintenanceAn MCP server that provides intelligent playlist curation tools using Spotify track data and audio feature analysis. It enables AI assistants to create mood-based playlists, find similar songs, analyze audio characteristics, and curate personalized music collections.
- AlicenseNot gradedqualityBmaintenanceAI-native MCP server for Qobuz that enables searching, browsing, and managing your music library, including favorites, playlists, and current playback.20MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
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/miziodel/navigravity'
If you have feedback or need assistance with the MCP directory API, please join our Discord server