SpotifyGetInfo

Instructions

Implementation Reference

• src/spotify_mcp/spotify_api.py:78-112 (handler)

  Core handler implementing the tool logic: fetches detailed Spotify item information (track, album, artist, playlist) using spotipy and parses results.

  def get_info(self, item_uri: str) -> dict:
      """
      Returns more info about item.
      - item_uri: uri. Looks like 'spotify:track:xxxxxx', 'spotify:album:xxxxxx', etc.
      """
      _, qtype, item_id = item_uri.split(":")
      match qtype:
          case 'track':
              return utils.parse_track(self.sp.track(item_id), detailed=True)
          case 'album':
              album_info = utils.parse_album(self.sp.album(item_id), detailed=True)
              return album_info
          case 'artist':
              artist_info = utils.parse_artist(self.sp.artist(item_id), detailed=True)
              albums = self.sp.artist_albums(item_id)
              top_tracks = self.sp.artist_top_tracks(item_id)['tracks']
              albums_and_tracks = {
                  'albums': albums,
                  'tracks': {'items': top_tracks}
              }
              parsed_info = utils.parse_search_results(albums_and_tracks, qtype="album,track")
              artist_info['top_tracks'] = parsed_info['tracks']
              artist_info['albums'] = parsed_info['albums']
  
              return artist_info
          case 'playlist':
              if self.username is None:
                  self.set_username()
              playlist = self.sp.playlist(item_id)
              self.logger.info(f"playlist info is {playlist}")
              playlist_info = utils.parse_playlist(playlist, self.username, detailed=True)
  
              return playlist_info
  
      raise ValueError(f"Unknown qtype {qtype}")

• src/spotify_mcp/server.py:228-237 (handler)

  Tool dispatch handler in @server.call_tool(): extracts item_uri argument and calls spotify_client.get_info, formats response as JSON.

  case "GetInfo":
      logger.info(f"Getting item info with arguments: {arguments}")
      item_info = spotify_client.get_info(
          item_uri=arguments.get("item_uri")
      )
      return [types.TextContent(
          type="text",
          text=json.dumps(item_info, indent=2)
      )]

• src/spotify_mcp/server.py:72-77 (schema)

  Pydantic input schema/model for SpotifyGetInfo tool, defining required 'item_uri' field.

  class GetInfo(ToolModel):
      """Get detailed information about a Spotify item (track, album, artist, or playlist)."""
      item_uri: str = Field(description="URI of the item to get information about. " +
                                        "If 'playlist' or 'album', returns its tracks. " +
                                        "If 'artist', returns albums and top tracks.")

• src/spotify_mcp/server.py:116-129 (registration)

  Registers SpotifyGetInfo via GetInfo.as_tool() in the list of tools returned by @server.list_tools().

  @server.list_tools()
  async def handle_list_tools() -> list[types.Tool]:
      """List available tools."""
      logger.info("Listing available tools")
      # await server.request_context.session.send_notification("are you recieving this notification?")
      tools = [
          Playback.as_tool(),
          Search.as_tool(),
          Queue.as_tool(),
          GetInfo.as_tool(),
          Playlist.as_tool(),
      ]
      logger.info(f"Available tools: {[tool.name for tool in tools]}")
      return tools

• src/spotify_mcp/server.py:43-50 (schema)

  Base ToolModel class with as_tool() method that constructs the tool definition including name 'SpotifyGetInfo' from class name 'GetInfo'.

  class ToolModel(BaseModel):
      @classmethod
      def as_tool(cls):
          return types.Tool(
              name="Spotify" + cls.__name__,
              description=cls.__doc__,
              inputSchema=cls.model_json_schema()
          )