Skip to main content
Glama
keenanbb

TIDAL MCP Server

by keenanbb

get_track_radio

Discover similar tracks to any TIDAL song to expand playlists and find new music based on your current listening preferences.

Instructions

Get tracks similar to a seed track (track radio).

This returns TIDAL's native recommendations based on the specified track, useful for music discovery and creating "similar music" playlists.

Args: track_id: ID of the seed track limit: Maximum tracks to return (default: 20, max: 100)

Returns: List of similar tracks with seed track info

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
track_idYes
limitNo

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault
countYesNumber of tracks returned
statusYesOperation status (success/error)
tracksYesList of recommended tracks
seed_idYesID of the seed track or artist
seed_nameYesName of the seed track or artist
seed_typeYesType of seed (track/artist)

Implementation Reference

  • The handler function decorated with @mcp.tool() that implements the get_track_radio tool. It authenticates, fetches the seed track, calls tidalapi's get_track_radio, maps to Track models, and returns RadioTracks.
    @mcp.tool()
    async def get_track_radio(track_id: str, limit: int = 20) -> RadioTracks:
        """
        Get tracks similar to a seed track (track radio).
    
        This returns TIDAL's native recommendations based on the specified track,
        useful for music discovery and creating "similar music" playlists.
    
        Args:
            track_id: ID of the seed track
            limit: Maximum tracks to return (default: 20, max: 100)
    
        Returns:
            List of similar tracks with seed track info
        """
        if not await ensure_authenticated():
            raise ToolError("Not authenticated. Please run the 'login' tool first.")
    
        try:
            limit = min(max(1, limit), 100)
    
            # Get the seed track first
            track = await anyio.to_thread.run_sync(session.track, track_id)
            if not track:
                raise ToolError(f"Track with ID '{track_id}' not found")
    
            seed_name = f"{track.name} by {track.artist.name if track.artist else 'Unknown Artist'}"
    
            # Get radio tracks
            radio_tracks = await anyio.to_thread.run_sync(
                lambda: track.get_track_radio(limit=limit)
            )
    
            tracks = []
            for t in radio_tracks:
                tracks.append(
                    Track(
                        id=str(t.id),
                        title=t.name,
                        artist=t.artist.name if t.artist else "Unknown Artist",
                        album=t.album.name if t.album else "Unknown Album",
                        duration_seconds=t.duration,
                        url=f"https://tidal.com/browse/track/{t.id}",
                    )
                )
    
            return RadioTracks(
                status="success",
                seed_id=track_id,
                seed_type="track",
                seed_name=seed_name,
                count=len(tracks),
                tracks=tracks,
            )
        except ToolError:
            raise
        except Exception as e:
            raise ToolError(f"Failed to get track radio: {str(e)}")
  • Pydantic BaseModel defining the structured output schema for the get_track_radio tool response, including seed info and list of recommended tracks.
    class RadioTracks(BaseModel):
        """Radio/recommendation tracks based on a seed track or artist."""
    
        status: str = Field(description="Operation status (success/error)")
        seed_id: str = Field(description="ID of the seed track or artist")
        seed_type: str = Field(description="Type of seed (track/artist)")
        seed_name: str = Field(description="Name of the seed track or artist")
        count: int = Field(description="Number of tracks returned")
        tracks: List[Track] = Field(description="List of recommended tracks")
  • The @mcp.tool() decorator registers the get_track_radio function as an MCP tool.
    @mcp.tool()
  • Helper lambda that calls the underlying tidalapi Track.get_track_radio method to fetch similar tracks.
    radio_tracks = await anyio.to_thread.run_sync(
        lambda: track.get_track_radio(limit=limit)
    )
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It adequately describes the core function and return format, but lacks details on rate limits, authentication requirements, error conditions, or pagination behavior. The mention of 'TIDAL's native recommendations' adds some context about the recommendation source, but more operational details would be helpful for a tool with no annotation coverage.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured and front-loaded with the core purpose, followed by usage context, parameter details, and return information. Every sentence earns its place, with no redundant or verbose phrasing. The bullet-like formatting for Args and Returns enhances readability without wasting space.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's moderate complexity (2 parameters, no annotations, but with an output schema), the description is reasonably complete. It covers purpose, usage, parameters, and returns adequately. The output schema existence means the description doesn't need to detail return values, but it could benefit from more behavioral context (e.g., error handling) to be fully comprehensive.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It successfully explains both parameters: 'track_id' as 'ID of the seed track' and 'limit' with its default (20) and maximum (100) values. This adds meaningful semantics beyond the bare schema types, though it doesn't specify the format of track_id (e.g., whether it's a TIDAL-specific identifier).

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

Purpose5/5

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

The description clearly states the specific action ('Get tracks similar to a seed track'), identifies the resource ('track radio'), and distinguishes it from siblings like 'get_artist_radio' or 'get_similar_artists' by focusing on track-based recommendations. The phrase 'TIDAL's native recommendations' adds specificity beyond a generic similarity function.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context for when to use this tool ('music discovery and creating "similar music" playlists'), but does not explicitly state when not to use it or name alternatives among siblings. It implies usage for track-based similarity rather than artist or album-based options, but lacks explicit exclusions or comparisons.

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

Install Server

Other Tools

Latest Blog Posts

MCP directory API

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

curl -X GET 'https://glama.ai/api/mcp/v1/servers/keenanbb/tidal-mcp'

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