diff --git a/data/media/audio.mp3 b/data/media/audio.mp3
new file mode 100644
index 0000000..3f2741d
Binary files /dev/null and b/data/media/audio.mp3 differ
diff --git a/data/media/example.pdf b/data/media/example.pdf
new file mode 100644
index 0000000..299531c
Binary files /dev/null and b/data/media/example.pdf differ
diff --git a/data/media/image.jpg b/data/media/image.jpg
new file mode 100644
index 0000000..685e5a4
Binary files /dev/null and b/data/media/image.jpg differ
diff --git a/data/media/table.parquet b/data/media/table.parquet
new file mode 100644
index 0000000..8326840
Binary files /dev/null and b/data/media/table.parquet differ
diff --git a/data/media/video.mp4 b/data/media/video.mp4
new file mode 100644
index 0000000..d9ae00b
Binary files /dev/null and b/data/media/video.mp4 differ
diff --git a/docs/media-urls.md b/docs/media-urls.md
index e11d392..025d11d 100644
--- a/docs/media-urls.md
+++ b/docs/media-urls.md
@@ -62,6 +62,26 @@ For **every cell in every row**:
 [useProcessedRowData.ts](../smoosense-gui/src/lib/hooks/useProcessedRowData.ts)
 - Returns the processed data with all media URLs resolved
 
+## Query Tab Processing
+
+The Query tab also processes media URLs in query results:
+
+**Location**: `SqlQueryPanel.tsx` @ [SqlQueryPanel.tsx](../smoosense-gui/src/components/sql/SqlQueryPanel.tsx)
+
+**Process**:
+1. Execute SQL query via `/api/query` endpoint
+2. Receive results as `{column_names, rows}`
+3. Transform rows using `_.zipObject(column_names, rows)`
+4. **Process media URLs** using same logic as Samples tab:
+   - For each cell, check `needToResolveMediaUrl(value)`
+   - If true, call `resolveAssetUrl(value, tablePath, baseUrl)`
+5. Render in `BasicAGTable` with auto-detected cell renderers
+
+**Media Rendering**:
+- Images displayed in `ImageCellRenderer`
+- Videos displayed in `VideoCellRenderer`
+- Audio displayed in `AudioCellRenderer`
+- Cell renderers auto-detected via `inferRenderTypeFromData()`
 
 ## Backend Integration
 
diff --git a/smoosense-gui/src/components/common/BasicAGTable.tsx b/smoosense-gui/src/components/common/BasicAGTable.tsx
index 573bc82..701036a 100644
--- a/smoosense-gui/src/components/common/BasicAGTable.tsx
+++ b/smoosense-gui/src/components/common/BasicAGTable.tsx
@@ -27,13 +27,12 @@ export default function BasicAGTable({ data, className = '', onGridReady, colDef
   const baseColumnDefs = inferColumnDefinitions(data)
 
   // Apply overrides if provided
-  const columnDefs = colDefOverrides
-    ? baseColumnDefs.map(colDef => {
-        const fieldName = colDef.field
-        const overrides = fieldName ? colDefOverrides[fieldName] : undefined
-        return overrides ? { ...colDef, ...overrides } : colDef
-      })
-    : baseColumnDefs
+  const columnDefs = baseColumnDefs.map(colDef => {
+    const fieldName = colDef.field
+    const overrides = colDefOverrides && fieldName ? colDefOverrides[fieldName] : undefined
+
+    return overrides ? { ...colDef, ...overrides } : colDef
+  })
 
   // Construct final grid options
   const finalGridOptions: GridOptions = {
diff --git a/smoosense-gui/src/components/common/ImageBlock.tsx b/smoosense-gui/src/components/common/ImageBlock.tsx
index 5ed31ac..aae35b4 100644
--- a/smoosense-gui/src/components/common/ImageBlock.tsx
+++ b/smoosense-gui/src/components/common/ImageBlock.tsx
@@ -1,7 +1,6 @@
 'use client'
 
 import { useAppSelector } from '@/lib/hooks'
-import { proxyedUrl } from '@/lib/utils/urlUtils'
 
 interface ImageBlockProps {
   src: string
@@ -19,7 +18,6 @@ export default function ImageBlock({
   neverFitCover = false
 }: ImageBlockProps) {
   const cropMediaToFitCover = useAppSelector((state) => state.ui.cropMediaToFitCover)
-  const imageUrl = proxyedUrl(src)
 
   const finalClassName = `${className} ${(cropMediaToFitCover && !neverFitCover) ? 'object-cover' : 'object-contain'}`.trim()
 
@@ -31,7 +29,7 @@ export default function ImageBlock({
 
   return (
     <img
-      src={imageUrl}
+      src={src}
       alt={alt}
       className={finalClassName}
       style={style}
diff --git a/smoosense-gui/src/components/common/VideoPlayer.tsx b/smoosense-gui/src/components/common/VideoPlayer.tsx
index 41a90a9..e683b77 100644
--- a/smoosense-gui/src/components/common/VideoPlayer.tsx
+++ b/smoosense-gui/src/components/common/VideoPlayer.tsx
@@ -2,7 +2,6 @@
 
 import { memo, useRef, useEffect, useState } from 'react'
 import { useAppSelector } from '@/lib/hooks'
-import { proxyedUrl } from '@/lib/utils/urlUtils'
 import { Play } from 'lucide-react'
 
 export interface VideoPlayerProps {
@@ -27,8 +26,6 @@ const VideoPlayer = memo(function VideoPlayer({
   const autoPlayAllVideos = useAppSelector((state) => state.ui.autoPlayAllVideos)
   const cropMediaToFitCover = useAppSelector((state) => state.ui.cropMediaToFitCover)
 
-  const videoUrl = proxyedUrl(src)
-
   // Apply crop fit logic - always take full width and height
   const finalClassName = cropMediaToFitCover
     ? `w-full h-full object-cover ${className || ''}`.trim()
@@ -108,7 +105,7 @@ const VideoPlayer = memo(function VideoPlayer({
     >
       <video
         ref={videoRef}
-        src={videoUrl}
+        src={src}
         className={finalClassName}
         muted={galleryVideoMuted}
         autoPlay={shouldAutoPlay}
diff --git a/smoosense-gui/src/components/gallery/Gallery.tsx b/smoosense-gui/src/components/gallery/Gallery.tsx
index 71e73ab..e6f03f8 100644
--- a/smoosense-gui/src/components/gallery/Gallery.tsx
+++ b/smoosense-gui/src/components/gallery/Gallery.tsx
@@ -1,8 +1,7 @@
 'use client'
 
 import { useAppSelector, useAppDispatch } from '@/lib/hooks'
-import { useRenderType } from '@/lib/hooks'
-import { useProcessedRowData } from '@/lib/hooks/useProcessedRowData'
+import { useRenderType, useRowData } from '@/lib/hooks'
 import { setJustClickedRowId } from '@/lib/features/viewing/viewingSlice'
 import { handPickRow } from '@/lib/features/handPickedRows/handPickedRowsSlice'
 import { isVisualType } from '@/lib/utils/renderTypeUtils'
@@ -12,7 +11,7 @@ import GalleryItem from './GalleryItem'
 
 export default function Gallery() {
   const dispatch = useAppDispatch()
-  const { data: rowData } = useProcessedRowData()
+  const { data: rowData } = useRowData()
   const renderTypeColumns = useRenderType()
   const columnForGalleryVisual = useAppSelector((state) => state.ui.columnForGalleryVisual)
   const columnForGalleryCaption = useAppSelector((state) => state.ui.columnForGalleryCaption)
diff --git a/smoosense-gui/src/components/gallery/GalleryItemVisual.tsx b/smoosense-gui/src/components/gallery/GalleryItemVisual.tsx
index 778cf6d..656b23f 100644
--- a/smoosense-gui/src/components/gallery/GalleryItemVisual.tsx
+++ b/smoosense-gui/src/components/gallery/GalleryItemVisual.tsx
@@ -1,7 +1,7 @@
 'use client'
 
 import { RenderType } from '@/lib/utils/agGridCellRenderers'
-import { proxyedUrl } from '@/lib/utils/urlUtils'
+import { mayResolveUrl } from '@/lib/utils/mediaUrlUtils'
 import { parseBbox, buildBboxVizUrl } from '@/lib/utils/bboxUtils'
 import ImageBlock from '@/components/common/ImageBlock'
 import ImageMask from '@/components/viz/ImageMask'
@@ -24,8 +24,13 @@ export default function GalleryItemVisual({
   index,
   galleryItemHeight
 }: GalleryItemVisualProps) {
+  const tablePath = useAppSelector((state) => state.ui.tablePath)
   const baseUrl = useAppSelector((state) => state.ui.baseUrl)
 
+  // Resolve URLs once to avoid repeated function calls
+  const resolvedVisualUrl = mayResolveUrl({ value: visualValue, tablePath, baseUrl })
+  const resolvedImageUrl = mayResolveUrl({ value: row.image_url, tablePath, baseUrl })
+
   return (
     <div
       className="relative overflow-hidden"
@@ -33,7 +38,7 @@ export default function GalleryItemVisual({
     >
       {renderType === RenderType.ImageUrl && (
         <ImageBlock
-          src={String(visualValue)}
+          src={resolvedVisualUrl}
           alt={`Row ${index + 1}`}
           className="w-full h-full"
         />
@@ -41,19 +46,19 @@ export default function GalleryItemVisual({
 
       {renderType === RenderType.ImageMask && (
         <ImageMask
-          image_url={String(row.image_url)}
-          mask_url={String(visualValue)}
+          image_url={resolvedImageUrl}
+          mask_url={resolvedVisualUrl}
           alt={`Row ${index + 1}`}
         />
       )}
 
       {renderType === RenderType.VideoUrl && (
-        <GalleryVideoItem visualValue={String(visualValue)} />
+        <GalleryVideoItem visualValue={resolvedVisualUrl} />
       )}
 
       {renderType === RenderType.AudioUrl && (
         <div className="w-full h-full flex items-center justify-center">
-          <AudioMiniMelSpectrogram audioUrl={proxyedUrl(String(visualValue))} height={galleryItemHeight} allowPopOver={true} />
+          <AudioMiniMelSpectrogram audioUrl={resolvedVisualUrl} height={galleryItemHeight} allowPopOver={true} />
         </div>
       )}
 
@@ -61,11 +66,11 @@ export default function GalleryItemVisual({
         const bbox = parseBbox(visualValue)
         const imageUrl = row.image_url
 
-        if (!bbox || !imageUrl || typeof imageUrl !== 'string' || !baseUrl) {
+        if (!bbox || !imageUrl || typeof imageUrl !== 'string' || !baseUrl || !tablePath) {
           return null
         }
 
-        const vizUrl = buildBboxVizUrl(imageUrl, [bbox], baseUrl)
+        const vizUrl = buildBboxVizUrl(imageUrl, [bbox], tablePath, baseUrl)
 
         return (
           <iframe
@@ -87,7 +92,7 @@ export default function GalleryItemVisual({
 
         return (
           <iframe
-            src={proxyedUrl(iframeUrl)}
+            src={iframeUrl}
             className="w-full h-full border-0"
             title={`Row ${index + 1}`}
             style={{ backgroundColor: 'transparent' }}
diff --git a/smoosense-gui/src/components/table/MainTable.tsx b/smoosense-gui/src/components/table/MainTable.tsx
index c7b2e6e..d66108e 100644
--- a/smoosense-gui/src/components/table/MainTable.tsx
+++ b/smoosense-gui/src/components/table/MainTable.tsx
@@ -4,9 +4,8 @@ import { useRef, useCallback, useImperativeHandle, forwardRef, useMemo, memo, us
 import { shallowEqual } from 'react-redux'
 import { AgGridReact } from 'ag-grid-react'
 import { GridReadyEvent, GridApi, ColumnResizedEvent, ColumnVisibleEvent, RowClickedEvent, SortChangedEvent } from 'ag-grid-community'
-import { useAGGridTheme, useAg, useRenderType } from '@/lib/hooks'
+import { useAGGridTheme, useAg, useRenderType, useRowData } from '@/lib/hooks'
 import { useAppSelector, useAppDispatch } from '@/lib/hooks'
-import { useProcessedRowData } from '@/lib/hooks/useProcessedRowData'
 import { AllCommunityModule, ModuleRegistry } from 'ag-grid-community'
 import { expandColDef, RenderType } from '@/lib/utils/agGridCellRenderers'
 import { AlertCircle } from 'lucide-react'
@@ -52,7 +51,7 @@ const MainTable = memo(forwardRef<MainTableRef, object>((_props, ref) => {
   const gridApiRef = useRef<GridApi | null>(null)
   
   // Always call hooks - but handle null tablePath gracefully in the hooks
-  const { data, error: dataError } = useProcessedRowData()
+  const { data, error: dataError } = useRowData()
   const { ag: baseColumnDefs } = useAg()
   const renderTypeColumns = useRenderType()
 
diff --git a/smoosense-gui/src/components/table/RowDetails.tsx b/smoosense-gui/src/components/table/RowDetails.tsx
index 127ca01..2b334ce 100644
--- a/smoosense-gui/src/components/table/RowDetails.tsx
+++ b/smoosense-gui/src/components/table/RowDetails.tsx
@@ -7,12 +7,9 @@ import JsonBox from '@/components/ui/JsonBox'
 import { RenderType } from '@/lib/utils/agGridCellRenderers'
 import { List, X } from 'lucide-react'
 import { isNil } from 'lodash'
-import { useRenderType } from '@/lib/hooks'
-import { useProcessedRowData } from '@/lib/hooks/useProcessedRowData'
+import { useRenderType, useRowData } from '@/lib/hooks'
 import AutoLink from '@/components/common/AutoLink'
 import { setShowRowDetailsPanel } from '@/lib/features/ui/uiSlice'
-import RichAudioPlayer from '@/components/audio/RichAudioPlayer'
-import { proxyedUrl } from '@/lib/utils/urlUtils'
 
 interface RowDetailsWrapperProps {
   children: React.ReactNode
@@ -51,10 +48,13 @@ function RowDetailsWrapper({ children }: RowDetailsWrapperProps) {
 
 
 
-function renderValueByType(value: unknown, renderType: RenderType): React.ReactNode {
+function renderValueByType(
+  value: unknown,
+  renderType: RenderType
+): React.ReactNode {
   if (value === null) return <span className="text-muted-foreground italic">null</span>
   if (value === undefined) return <span className="text-muted-foreground italic">undefined</span>
-  
+
   switch (renderType) {
     case RenderType.Json:
       if (typeof value === 'object' && !isNil(value)) {
@@ -71,55 +71,28 @@ function renderValueByType(value: unknown, renderType: RenderType): React.ReactN
         }
       }
       return <span className="text-sm font-mono">{String(value)}</span>
-    
-    case RenderType.ImageUrl:
-      if (typeof value === 'string') {
-        return (
-          <div>
-            <AutoLink url={value} className="text-xs font-mono" />
-          </div>
-        )
-      }
-      return <span className="text-sm font-mono">{String(value)}</span>
-    
+
     case RenderType.IFrame:
       if (typeof value === 'string') {
         return <AutoLink url={value} className="text-xs font-mono" />
       }
       return <span className="text-sm font-mono">{String(value)}</span>
-    
-    case RenderType.VideoUrl:
-      if (typeof value === 'string') {
-        return (
-          <div>
-            <AutoLink url={value} className="text-xs font-mono" />
-          </div>
-        )
-      }
-      return <span className="text-sm font-mono">{String(value)}</span>
-
-    case RenderType.AudioUrl:
-      if (typeof value === 'string') {
-        const audioUrl = proxyedUrl(value)
-        return <RichAudioPlayer audioUrl={audioUrl} autoPlay={false} />
-      }
-      return <span className="text-sm font-mono">{String(value)}</span>
 
     case RenderType.Boolean:
       return <span className={`font-medium`}>{String(value)}</span>
-    
+
     case RenderType.Number:
       return <span className="font-mono">{String(value)}</span>
-    
+
     default:
       return <span className="text-sm font-mono">{String(value)}</span>
   }
 }
 
 export default function RowDetails() {
-  // Get data from Redux store (using processed data that includes derived columns)
+  // Get data from Redux store
   const justClickedRowId = useAppSelector((state) => state.viewing.justClickedRowId)
-  const { data: rowData } = useProcessedRowData()
+  const { data: rowData } = useRowData()
   const columnDefs = useAppSelector((state) => state.ag.columnDefs)
   const renderTypeColumns = useRenderType()
 
diff --git a/smoosense-gui/src/components/ui/CellPopover.tsx b/smoosense-gui/src/components/ui/CellPopover.tsx
index 9d76f95..3422fc4 100644
--- a/smoosense-gui/src/components/ui/CellPopover.tsx
+++ b/smoosense-gui/src/components/ui/CellPopover.tsx
@@ -100,6 +100,7 @@ export default function CellPopover({
     <div className='flex flex-col h-full min-h-0'>
       <CellPopoverContentHeader
         url={url}
+        title={copyValue || undefined}
         isExpanded={isExpanded}
         onToggleExpand={handleToggleExpand}
         onClose={handleClose}
diff --git a/smoosense-gui/src/components/ui/CellPopoverContentHeader.tsx b/smoosense-gui/src/components/ui/CellPopoverContentHeader.tsx
index 213f5c3..5f78fff 100644
--- a/smoosense-gui/src/components/ui/CellPopoverContentHeader.tsx
+++ b/smoosense-gui/src/components/ui/CellPopoverContentHeader.tsx
@@ -1,9 +1,8 @@
 'use client'
 
-import { ReactNode, useState } from 'react'
-import { X, Maximize2, Minimize2, ExternalLink, Copy, Check } from 'lucide-react'
+import { ReactNode } from 'react'
+import { X, Maximize2, Minimize2, ExternalLink } from 'lucide-react'
 import { Button } from '@/components/ui/button'
-import { isNil } from 'lodash'
 
 interface HeaderButtonProps {
   onClick: () => void
@@ -30,8 +29,10 @@ function HeaderButton({ onClick, title, children, className = "" }: HeaderButton
 }
 
 interface CellPopoverContentHeaderProps {
-  /** URL to display with copy and open functionality */
+  /** URL to display with open functionality */
   url?: string | null
+  /** Title text to display */
+  title?: string | null
   /** Whether the popover is expanded */
   isExpanded: boolean
   /** Handler for expand/collapse toggle */
@@ -41,29 +42,16 @@ interface CellPopoverContentHeaderProps {
 }
 
 /**
- * Header component for CellPopover that shows URL with copy/open functionality
+ * Header component for CellPopover that shows URL with open functionality
  * and expand/close controls
  */
 export default function CellPopoverContentHeader({
   url,
+  title,
   isExpanded,
   onToggleExpand,
   onClose
 }: CellPopoverContentHeaderProps) {
-  const [copied, setCopied] = useState(false)
-
-  const handleCopy = async () => {
-    if (!url) return
-
-    try {
-      const textToCopy = isNil(url) ? 'null' : String(url)
-      await navigator.clipboard.writeText(textToCopy)
-      setCopied(true)
-      setTimeout(() => setCopied(false), 2000)
-    } catch {
-      // Fallback for older browsers or clipboard API errors
-    }
-  }
 
   const handleOpenInNewTab = () => {
     if (url) {
@@ -71,30 +59,25 @@ export default function CellPopoverContentHeader({
     }
   }
 
+  const displayText = title || url
+
   return (
     <div className="flex items-center justify-between border-b p-2 gap-2 bg-muted/50">
       <div className="flex-1 min-w-0">
-        {url && (
+        {displayText && (
           <div className="flex items-center gap-2">
             <code className="flex-1 text-xs bg-muted px-2 py-1 rounded truncate">
-              {url}
+              {displayText}
             </code>
-            <HeaderButton
-              onClick={handleCopy}
-              title={copied ? 'Copied!' : 'Copy to clipboard'}
-            >
-              {copied ? (
-                <Check className="h-4 w-4 text-green-600" />
-              ) : (
-                <Copy className="h-4 w-4" />
-              )}
-            </HeaderButton>
-            <HeaderButton
-              onClick={handleOpenInNewTab}
-              title="Open in new tab"
-            >
-              <ExternalLink className="h-4 w-4" />
-            </HeaderButton>
+
+            {url && (
+              <HeaderButton
+                onClick={handleOpenInNewTab}
+                title="Open in new tab"
+              >
+                <ExternalLink className="h-4 w-4" />
+              </HeaderButton>
+            )}
           </div>
         )}
       </div>
diff --git a/smoosense-gui/src/lib/features/processedRowData/__tests__/processedRowDataSlice.test.ts b/smoosense-gui/src/lib/features/processedRowData/__tests__/processedRowDataSlice.test.ts
deleted file mode 100644
index bacbc45..0000000
--- a/smoosense-gui/src/lib/features/processedRowData/__tests__/processedRowDataSlice.test.ts
+++ /dev/null
@@ -1,184 +0,0 @@
-import { configureStore } from '@reduxjs/toolkit'
-import processedRowDataReducer, { fetchProcessedRowData, type ProcessedRowDataState } from '../processedRowDataSlice'
-import { resolveAssetUrl } from '@/lib/utils/mediaUrlUtils'
-
-// Mock the dependencies
-jest.mock('@/lib/utils/urlUtils', () => ({
-  proxyAllUrlsInRowData: jest.fn(({ rowData }) => Promise.resolve(rowData)),
-  API_PREFIX: './api'
-}))
-
-jest.mock('@/lib/utils/derivedColumnUtils', () => ({
-  evaluateAllExpressionsForAllRows: jest.fn(({ rowData }) => Promise.resolve(rowData))
-}))
-
-interface TestStore {
-  processedRowData: ProcessedRowDataState
-  derivedColumns: { columns: unknown[] }
-}
-
-describe('processedRowDataSlice', () => {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let store: any
-
-  beforeEach(() => {
-    store = configureStore({
-      reducer: {
-        processedRowData: processedRowDataReducer,
-        derivedColumns: () => ({ columns: [] })
-      }
-    })
-  })
-
-  it('should handle initial state', () => {
-    const state = (store.getState() as TestStore).processedRowData
-    expect(state.data).toBeNull()
-    expect(state.loading).toBe(false)
-    expect(state.error).toBeNull()
-    expect(state.needRefresh).toBe(false)
-  })
-
-  it('should handle fetch with empty data', async () => {
-    const result = await store.dispatch(fetchProcessedRowData({ rawData: [] }))
-
-    // Should not dispatch due to shouldWait condition
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    expect((result as any).meta.requestStatus).toBe('fulfilled')
-  })
-
-  it('should handle fetch with valid data', async () => {
-    const testData = [{ id: 1, name: 'test' }]
-
-    const result = await store.dispatch(fetchProcessedRowData({ rawData: testData }))
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    expect((result as any).meta.requestStatus).toBe('fulfilled')
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    expect((result as any).payload).toEqual(testData)
-
-    const state = (store.getState() as TestStore).processedRowData
-    expect(state.data).toEqual(testData)
-    expect(state.loading).toBe(false)
-    expect(state.error).toBeNull()
-  })
-})
-
-describe('resolveAssetUrl', () => {
-  const baseUrl = 'http://localhost:8001'
-  const tablePath = '/data/folder/file.parquet'
-
-  describe('relative URLs starting with ./', () => {
-    it('should resolve relative URL with tablePath', () => {
-      const url = './images/photo.jpg'
-      const expected = 'api/get-file?path=%2Fdata%2Ffolder%2Fimages%2Fphoto.jpg&redirect=false'
-      expect(resolveAssetUrl(url, tablePath, baseUrl)).toBe(baseUrl + '/' + expected)
-    })
-
-    it('should resolve relative URL with nested path', () => {
-      const url = './subfolder/nested/file.txt'
-      const expected = 'api/get-file?path=%2Fdata%2Ffolder%2Fsubfolder%2Fnested%2Ffile.txt&redirect=false'
-      expect(resolveAssetUrl(url, tablePath, baseUrl)).toBe(baseUrl + '/' + expected)
-    })
-
-    it('should resolve relative URL with parent directory', () => {
-      const url = './../other/file.txt'
-      const expected = 'api/get-file?path=%2Fdata%2Ffolder%2F..%2Fother%2Ffile.txt&redirect=false'
-      expect(resolveAssetUrl(url, tablePath, baseUrl)).toBe(baseUrl + '/' + expected)
-    })
-  })
-
-  describe('absolute file paths starting with /', () => {
-    it('should convert absolute path to API URL with baseUrl', () => {
-      const url = '/data/images/photo.jpg'
-      const expected = 'api/get-file?path=%2Fdata%2Fimages%2Fphoto.jpg&redirect=false'
-      expect(resolveAssetUrl(url, tablePath, baseUrl)).toBe(baseUrl + '/' + expected)
-    })
-
-    it('should handle paths with spaces', () => {
-      const url = '/data/path with spaces/file.txt'
-      const expected = 'api/get-file?path=%2Fdata%2Fpath+with+spaces%2Ffile.txt&redirect=false'
-      expect(resolveAssetUrl(url, tablePath, baseUrl)).toBe(baseUrl + '/' + expected)
-    })
-
-    it('should handle paths with special characters', () => {
-      const url = '/data/file@#$%.txt'
-      const expected = 'api/get-file?path=%2Fdata%2Ffile%40%23%24%25.txt&redirect=false'
-      expect(resolveAssetUrl(url, tablePath, baseUrl)).toBe(baseUrl + '/' + expected)
-    })
-  })
-
-  describe('home directory paths starting with ~/', () => {
-    it('should convert home path to API URL with baseUrl', () => {
-      const url = '~/Documents/file.txt'
-      const expected = 'api/get-file?path=%7E%2FDocuments%2Ffile.txt&redirect=false'
-      expect(resolveAssetUrl(url, tablePath, baseUrl)).toBe(baseUrl + '/' + expected)
-    })
-
-    it('should handle home path with nested folders', () => {
-      const url = '~/folder/subfolder/file.txt'
-      const expected = 'api/get-file?path=%7E%2Ffolder%2Fsubfolder%2Ffile.txt&redirect=false'
-      expect(resolveAssetUrl(url, tablePath, baseUrl)).toBe(baseUrl + '/' + expected)
-    })
-  })
-
-  describe('S3 URLs', () => {
-    it('should proxy S3 URL through s3-proxy endpoint', () => {
-      const url = 's3://bucket/folder/file.txt'
-      const expected = 'api/s3-proxy?url=' + encodeURIComponent(url)
-      expect(resolveAssetUrl(url, tablePath, baseUrl)).toBe(baseUrl + '/' + expected)
-    })
-
-    it('should proxy S3 URL with special characters', () => {
-      const url = 's3://my-bucket/path with spaces/file@#.jpg'
-      const expected = 'api/s3-proxy?url=' + encodeURIComponent(url)
-      expect(resolveAssetUrl(url, tablePath, baseUrl)).toBe(baseUrl + '/' + expected)
-    })
-
-    it('should proxy S3 URL with nested paths', () => {
-      const url = 's3://bucket/folder/subfolder/image.png'
-      const expected = 'api/s3-proxy?url=' + encodeURIComponent(url)
-      expect(resolveAssetUrl(url, tablePath, baseUrl)).toBe(baseUrl + '/' + expected)
-    })
-  })
-
-  describe('absolute URLs', () => {
-    it('should return HTTP URL unchanged', () => {
-      const url = 'http://example.com/image.jpg'
-      expect(resolveAssetUrl(url, tablePath, baseUrl)).toBe(url)
-    })
-
-    it('should return HTTPS URL unchanged', () => {
-      const url = 'https://example.com/image.jpg'
-      expect(resolveAssetUrl(url, tablePath, baseUrl)).toBe(url)
-    })
-
-    it('should return other protocol URLs unchanged', () => {
-      const url = 'ftp://server/file.txt'
-      expect(resolveAssetUrl(url, tablePath, baseUrl)).toBe(url)
-    })
-
-    it('should return data URLs unchanged', () => {
-      const url = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg=='
-      expect(resolveAssetUrl(url, tablePath, baseUrl)).toBe(url)
-    })
-  })
-
-  describe('edge cases', () => {
-    it('should handle root path /', () => {
-      const url = '/'
-      const expected = 'api/get-file?path=%2F&redirect=false'
-      expect(resolveAssetUrl(url, tablePath, baseUrl)).toBe(baseUrl + '/' + expected)
-    })
-
-    it('should handle single file in root', () => {
-      const url = '/file.txt'
-      const expected = 'api/get-file?path=%2Ffile.txt&redirect=false'
-      expect(resolveAssetUrl(url, tablePath, baseUrl)).toBe(baseUrl + '/' + expected)
-    })
-
-    it('should handle URL with query parameters (absolute URL)', () => {
-      const url = 'https://example.com/image.jpg?size=large'
-      expect(resolveAssetUrl(url, tablePath, baseUrl)).toBe(url)
-    })
-  })
-})
\ No newline at end of file
diff --git a/smoosense-gui/src/lib/features/processedRowData/processedRowDataSlice.ts b/smoosense-gui/src/lib/features/processedRowData/processedRowDataSlice.ts
deleted file mode 100644
index 2849f58..0000000
--- a/smoosense-gui/src/lib/features/processedRowData/processedRowDataSlice.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-import {type BaseAsyncDataState, createAsyncDataSlice} from '@/lib/utils/createAsyncDataSlice'
-import {needToResolveMediaUrl, resolveAssetUrl} from '@/lib/utils/mediaUrlUtils'
-import {isNil, mapValues} from 'lodash'
-
-export type ProcessedRowDataState = BaseAsyncDataState<Record<string, unknown>[]>
-
-interface FetchProcessedRowDataParams {
-  rawData: Record<string, unknown>[]
-}
-
-// Processed row data fetch function
-const fetchProcessedRowDataFunction = async (
-  { rawData }: FetchProcessedRowDataParams,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  dispatch: any,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  getState?: any
-): Promise<Record<string, unknown>[]> => {
-  if (!rawData || rawData.length === 0) {
-    return []
-  }
-
-  // Process all cells: resolve media URLs
-  if (getState) {
-    const state = getState()
-    const tablePath = state.ui?.tablePath
-    const baseUrl = state.ui?.baseUrl
-
-    // Only process if both tablePath and baseUrl are available
-    if (tablePath && baseUrl) {
-      // Use pure functional map to transform data without mutation
-      return rawData.map((row) =>
-        mapValues(row, (value) =>
-          needToResolveMediaUrl(value)
-            ? resolveAssetUrl(value as string, tablePath, baseUrl)
-            : value
-        )
-      )
-    }
-  }
-
-  return rawData
-}
-
-// Should wait condition - check if rawData is provided
-const processedRowDataShouldWait = ({ rawData }: FetchProcessedRowDataParams) => {
-  return !isNil(rawData)
-}
-
-// Create the slice using the factory
-const sliceResult = createAsyncDataSlice<Record<string, unknown>[], FetchProcessedRowDataParams>({
-  name: 'processedRowData',
-  fetchFunction: fetchProcessedRowDataFunction,
-  shouldWait: processedRowDataShouldWait,
-  errorMessage: 'Failed to process row data'
-})
-
-export const processedRowDataSlice = sliceResult.slice
-export const fetchProcessedRowData = sliceResult.fetchThunk
-export const { clearProcessedRowData, setProcessedRowDataError, setNeedRefresh } = sliceResult.actions
-export default sliceResult.reducer
\ No newline at end of file
diff --git a/smoosense-gui/src/lib/hooks/__tests__/useProcessedRowData.test.tsx b/smoosense-gui/src/lib/hooks/__tests__/useProcessedRowData.test.tsx
deleted file mode 100644
index 91b753e..0000000
--- a/smoosense-gui/src/lib/hooks/__tests__/useProcessedRowData.test.tsx
+++ /dev/null
@@ -1,182 +0,0 @@
-import React from 'react'
-import { renderHook } from '@testing-library/react'
-import { Provider } from 'react-redux'
-import { configureStore } from '@reduxjs/toolkit'
-import { useProcessedRowData } from '../useProcessedRowData'
-import { useRowData } from '../useRowData'
-
-// Mock the dependencies
-jest.mock('../useRowData')
-jest.mock('../useAsyncData')
-
-const mockUseRowData = useRowData as jest.MockedFunction<typeof useRowData>
-
-// Mock useAsyncData
-jest.mock('../useAsyncData', () => ({
-  useAsyncData: jest.fn()
-}))
-
-import { useAsyncData } from '../useAsyncData'
-const mockUseAsyncData = useAsyncData as jest.MockedFunction<typeof useAsyncData>
-
-// Create a minimal store for testing
-const createTestStore = () => {
-  return configureStore({
-    reducer: {
-      processedRowData: (state = { data: null, loading: false, error: null, needRefresh: false }) => state,
-    },
-  })
-}
-
-const wrapper = ({ children }: { children: React.ReactNode }) => (
-  <Provider store={createTestStore()}>{children}</Provider>
-)
-
-describe('useProcessedRowData', () => {
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  it('should return empty array when rowData.data is empty list', () => {
-    // Mock useRowData to return empty array
-    mockUseRowData.mockReturnValue({
-      data: [],
-      loading: false,
-      error: null,
-      setNeedRefresh: jest.fn()
-    })
-
-    // Mock useAsyncData to return empty array when given empty rawData
-    mockUseAsyncData.mockReturnValue({
-      data: [],
-      loading: false,
-      error: null,
-      setNeedRefresh: jest.fn()
-    })
-
-    const { result } = renderHook(() => useProcessedRowData(), { wrapper })
-
-    expect(result.current.data).toEqual([])
-    expect(result.current.loading).toBe(false)
-    expect(result.current.error).toBe(null)
-  })
-
-  it('should call useAsyncData with correct params when rawData is empty array', () => {
-    // Mock useRowData to return empty array
-    mockUseRowData.mockReturnValue({
-      data: [],
-      loading: false,
-      error: null,
-      setNeedRefresh: jest.fn()
-    })
-
-    // Mock useAsyncData
-    mockUseAsyncData.mockReturnValue({
-      data: [],
-      loading: false,
-      error: null,
-      setNeedRefresh: jest.fn()
-    })
-
-    renderHook(() => useProcessedRowData(), { wrapper })
-
-    // Verify useAsyncData was called
-    expect(mockUseAsyncData).toHaveBeenCalledWith({
-      stateSelector: expect.any(Function),
-      fetchAction: expect.any(Function),
-      setNeedRefreshAction: expect.any(Function),
-      buildParams: expect.any(Function),
-      dependencies: [[]]
-    })
-
-    // Verify buildParams returns correct value for empty array
-    const call = mockUseAsyncData.mock.calls[0][0]
-    const buildParams = call.buildParams
-    const params = buildParams()
-
-    expect(params).toEqual({
-      rawData: []
-    })
-  })
-
-  it('should handle loading state correctly', () => {
-    // Mock useRowData to return empty array while loading (simulating data being fetched)
-    mockUseRowData.mockReturnValue({
-      data: [], // useRowData never returns null, always returns array
-      loading: true,
-      error: null,
-      setNeedRefresh: jest.fn()
-    })
-
-    // Mock useAsyncData to return loading state
-    mockUseAsyncData.mockReturnValue({
-      data: [],
-      loading: true,
-      error: null,
-      setNeedRefresh: jest.fn()
-    })
-
-    const { result } = renderHook(() => useProcessedRowData(), { wrapper })
-
-    // Verify the final result during loading
-    expect(result.current.data).toEqual([])
-    expect(result.current.loading).toBe(true) // Should show loading from both sources
-  })
-
-  it('should fallback to empty array when processedData is null', () => {
-    // Mock useRowData to return some data
-    mockUseRowData.mockReturnValue({
-      data: [{ id: 1 }],
-      loading: false,
-      error: null,
-      setNeedRefresh: jest.fn()
-    })
-
-    // Mock useAsyncData to return null data
-    mockUseAsyncData.mockReturnValue({
-      data: null,
-      loading: false,
-      error: null,
-      setNeedRefresh: jest.fn()
-    })
-
-    const { result } = renderHook(() => useProcessedRowData(), { wrapper })
-
-    // Should fallback to empty array due to (processedData || [])
-    expect(result.current.data).toEqual([])
-  })
-
-  it('should process empty array and return empty array', () => {
-    // This is the key test case - empty filter results should be processed
-    mockUseRowData.mockReturnValue({
-      data: [], // Empty array from filters
-      loading: false,
-      error: null,
-      setNeedRefresh: jest.fn()
-    })
-
-    // Mock useAsyncData to simulate processing empty array and returning empty array
-    mockUseAsyncData.mockReturnValue({
-      data: [], // Processed empty array should still be empty array
-      loading: false,
-      error: null,
-      setNeedRefresh: jest.fn()
-    })
-
-    const { result } = renderHook(() => useProcessedRowData(), { wrapper })
-
-    // Verify that buildParams is called with empty array (not skipped)
-    const call = mockUseAsyncData.mock.calls[0][0]
-    const buildParams = call.buildParams
-    const params = buildParams()
-
-    expect(params).toEqual({
-      rawData: []
-    })
-
-    // Final result should be empty array
-    expect(result.current.data).toEqual([])
-    expect(result.current.loading).toBe(false)
-    expect(result.current.error).toBe(null)
-  })
-})
\ No newline at end of file
diff --git a/smoosense-gui/src/lib/hooks/useIsCategorical.ts b/smoosense-gui/src/lib/hooks/useIsCategorical.ts
index ac2961b..0fb0dc8 100644
--- a/smoosense-gui/src/lib/hooks/useIsCategorical.ts
+++ b/smoosense-gui/src/lib/hooks/useIsCategorical.ts
@@ -58,7 +58,7 @@ export function useIsCategorical(columnName: string): {
       // - cardinality is low
       // - cntD < 5 OR distinct ratio < 10%
       if (cardinality === 'low' && !isNil(cntD) && !isNil(distinctRatio)) {
-        isCategorical = cntD < 5 || (distinctRatio < 0.1 && cntD < 100);
+        isCategorical = distinctRatio < 0.3 && cntD < 100;
       } else if (cardinality === 'high') {
         isCategorical = false
       }
diff --git a/smoosense-gui/src/lib/hooks/useProcessedRowData.ts b/smoosense-gui/src/lib/hooks/useProcessedRowData.ts
deleted file mode 100644
index 7fc9e0d..0000000
--- a/smoosense-gui/src/lib/hooks/useProcessedRowData.ts
+++ /dev/null
@@ -1,33 +0,0 @@
-import { useRowData } from './useRowData'
-import { useAsyncData } from './useAsyncData'
-import { fetchProcessedRowData, setNeedRefresh as setNeedRefreshAction } from '@/lib/features/processedRowData/processedRowDataSlice'
-
-interface UseProcessedRowDataResult {
-  data: Record<string, unknown>[]
-  loading: boolean
-  error: string | null
-  setNeedRefresh: (needRefresh: boolean) => void
-}
-
-export function useProcessedRowData(): UseProcessedRowDataResult {
-  // Get raw row data first
-  const { data: rawData, loading: rawDataLoading, error: rawDataError } = useRowData()
-
-  // Use the async data pattern for processed row data
-  const { data: processedData, loading: processedLoading, error: processedError, setNeedRefresh } = useAsyncData({
-    stateSelector: (state) => state.processedRowData,
-    fetchAction: fetchProcessedRowData,
-    setNeedRefreshAction: setNeedRefreshAction,
-    buildParams: () => {
-      return { rawData }
-    },
-    dependencies: [rawData]
-  })
-
-  return {
-    data: (processedData || []) as Record<string, unknown>[],
-    loading: rawDataLoading || processedLoading,
-    error: rawDataError || processedError,
-    setNeedRefresh
-  }
-}
\ No newline at end of file
diff --git a/smoosense-gui/src/lib/store.ts b/smoosense-gui/src/lib/store.ts
index 88989cf..1e15d8f 100644
--- a/smoosense-gui/src/lib/store.ts
+++ b/smoosense-gui/src/lib/store.ts
@@ -3,7 +3,6 @@ import uiReducer from './features/ui/uiSlice'
 import columnMetaReducer from './features/columnMeta/columnMetaSlice'
 import sqlHistoryReducer from './features/sqlHistory/sqlHistorySlice'
 import rowDataReducer from './features/rowData/rowDataSlice'
-import processedRowDataReducer from './features/processedRowData/processedRowDataSlice'
 import viewingReducer from './features/viewing/viewingSlice'
 import agReducer from './features/colDefs/agSlice'
 import columnsReducer from './features/columns/columnsSlice'
@@ -23,7 +22,6 @@ const storeInstance = configureStore({
     columnMeta: columnMetaReducer,
     sqlHistory: sqlHistoryReducer,
     rowData: rowDataReducer,
-    processedRowData: processedRowDataReducer,
     viewing: viewingReducer,
     ag: agReducer,
     columns: columnsReducer,
diff --git a/smoosense-gui/src/lib/test-utils.ts b/smoosense-gui/src/lib/test-utils.ts
index 4ca2651..ca822f7 100644
--- a/smoosense-gui/src/lib/test-utils.ts
+++ b/smoosense-gui/src/lib/test-utils.ts
@@ -3,7 +3,6 @@ import uiReducer from '@/lib/features/ui/uiSlice'
 import columnMetaReducer from '@/lib/features/columnMeta/columnMetaSlice'
 import sqlHistoryReducer from '@/lib/features/sqlHistory/sqlHistorySlice'
 import rowDataReducer from '@/lib/features/rowData/rowDataSlice'
-import processedRowDataReducer from '@/lib/features/processedRowData/processedRowDataSlice'
 import viewingReducer from '@/lib/features/viewing/viewingSlice'
 import agReducer from '@/lib/features/colDefs/agSlice'
 import columnsReducer from '@/lib/features/columns/columnsSlice'
@@ -83,12 +82,6 @@ export function createDefaultTestState(): RootState {
       error: null,
       needRefresh: false,
     },
-    processedRowData: {
-      data: null,
-      loading: false,
-      error: null,
-      needRefresh: false,
-    },
     viewing: {
       pageSize: 10,
       pageNumber: 1,
@@ -222,7 +215,6 @@ export function createTestStore(stateOverrides?: DeepPartial<RootState>) {
       columnMeta: columnMetaReducer,
       sqlHistory: sqlHistoryReducer,
       rowData: rowDataReducer,
-      processedRowData: processedRowDataReducer,
       viewing: viewingReducer,
       ag: agReducer,
       columns: columnsReducer,
diff --git a/smoosense-gui/src/lib/utils/__tests__/ImageCellRenderer.test.tsx b/smoosense-gui/src/lib/utils/__tests__/ImageCellRenderer.test.tsx
index f630137..211ca76 100644
--- a/smoosense-gui/src/lib/utils/__tests__/ImageCellRenderer.test.tsx
+++ b/smoosense-gui/src/lib/utils/__tests__/ImageCellRenderer.test.tsx
@@ -70,28 +70,18 @@ describe('ImageCellRenderer', () => {
   })
 
   describe('Proxied URLs', () => {
+    // Set up Redux state with tablePath and baseUrl for URL resolution
+    const testState = {
+      ui: {
+        tablePath: 's3://test-bucket/data.parquet',
+        baseUrl: 'http://localhost:8000'
+      }
+    }
+
     it('should use proxied URL for S3 image URLs', () => {
       const s3Url = 's3://bucket/image.jpg'
-      const expectedProxiedUrl = './api/s3-proxy?url=' + encodeURIComponent(s3Url)
-      renderWithProvider(<ImageCellRenderer value={s3Url} />)
-      const img = screen.getByRole('img', { name: 'Image' })
-      expect(img).toBeInTheDocument()
-      expect(img).toHaveAttribute('src', expectedProxiedUrl)
-    })
-
-    it('should use proxied URL for FTP image URLs', () => {
-      const ftpUrl = 'ftp://server/image.png'
-      const expectedProxiedUrl = './api/s3-proxy?url=' + encodeURIComponent(ftpUrl)
-      renderWithProvider(<ImageCellRenderer value={ftpUrl} />)
-      const img = screen.getByRole('img', { name: 'Image' })
-      expect(img).toBeInTheDocument()
-      expect(img).toHaveAttribute('src', expectedProxiedUrl)
-    })
-
-    it('should use proxied URL for file:// URLs', () => {
-      const fileUrl = 'file:///local/image.gif'
-      const expectedProxiedUrl = './api/s3-proxy?url=' + encodeURIComponent(fileUrl)
-      renderWithProvider(<ImageCellRenderer value={fileUrl} />)
+      const expectedProxiedUrl = 'http://localhost:8000/api/s3-proxy?url=' + encodeURIComponent(s3Url)
+      renderWithProvider(<ImageCellRenderer value={s3Url} />, testState)
       const img = screen.getByRole('img', { name: 'Image' })
       expect(img).toBeInTheDocument()
       expect(img).toHaveAttribute('src', expectedProxiedUrl)
@@ -115,8 +105,8 @@ describe('ImageCellRenderer', () => {
 
     it('should properly encode URLs with special characters for proxy', () => {
       const s3UrlWithSpaces = 's3://bucket/path with spaces/image.jpg'
-      const expectedProxiedUrl = './api/s3-proxy?url=' + encodeURIComponent(s3UrlWithSpaces)
-      renderWithProvider(<ImageCellRenderer value={s3UrlWithSpaces} />)
+      const expectedProxiedUrl = 'http://localhost:8000/api/s3-proxy?url=' + encodeURIComponent(s3UrlWithSpaces)
+      renderWithProvider(<ImageCellRenderer value={s3UrlWithSpaces} />, testState)
       const img = screen.getByRole('img', { name: 'Image' })
       expect(img).toBeInTheDocument()
       expect(img).toHaveAttribute('src', expectedProxiedUrl)
diff --git a/smoosense-gui/src/lib/utils/__tests__/mediaUrlUtils.test.ts b/smoosense-gui/src/lib/utils/__tests__/mediaUrlUtils.test.ts
index 286efe5..08b1c75 100644
--- a/smoosense-gui/src/lib/utils/__tests__/mediaUrlUtils.test.ts
+++ b/smoosense-gui/src/lib/utils/__tests__/mediaUrlUtils.test.ts
@@ -51,19 +51,18 @@ describe('needToResolveMediaUrl', () => {
       expect(needToResolveMediaUrl('s3://my-bucket/images/photo.jpg')).toBe(true)
       expect(needToResolveMediaUrl('s3://bucket/video.mp4')).toBe(true)
       expect(needToResolveMediaUrl('s3://bucket/music.wav')).toBe(true)
+      expect(needToResolveMediaUrl('s3://bucket/document.pdf')).toBe(true)
     })
 
     it('should return false for S3 URLs without media extensions', () => {
       expect(needToResolveMediaUrl('s3://bucket/file.txt')).toBe(false)
       expect(needToResolveMediaUrl('s3://bucket/data.csv')).toBe(false)
-      expect(needToResolveMediaUrl('s3://bucket/document.pdf')).toBe(false)
     })
   })
 
   describe('strings with path prefixes but non-media extensions', () => {
     it('should return false for relative paths with non-media extensions', () => {
       expect(needToResolveMediaUrl('./file.txt')).toBe(false)
-      expect(needToResolveMediaUrl('./document.pdf')).toBe(false)
       expect(needToResolveMediaUrl('./data.json')).toBe(false)
     })
 
@@ -100,6 +99,11 @@ describe('needToResolveMediaUrl', () => {
       expect(needToResolveMediaUrl('./voice.ogg')).toBe(true)
       expect(needToResolveMediaUrl('./song.m4a')).toBe(true)
     })
+
+    it('should return true for relative PDF paths', () => {
+      expect(needToResolveMediaUrl('./document.pdf')).toBe(true)
+      expect(needToResolveMediaUrl('./docs/report.pdf')).toBe(true)
+    })
   })
 
   describe('valid media URLs with absolute paths', () => {
@@ -118,6 +122,11 @@ describe('needToResolveMediaUrl', () => {
       expect(needToResolveMediaUrl('/audio/sound.mp3')).toBe(true)
       expect(needToResolveMediaUrl('/music/track.wav')).toBe(true)
     })
+
+    it('should return true for absolute PDF paths', () => {
+      expect(needToResolveMediaUrl('/documents/report.pdf')).toBe(true)
+      expect(needToResolveMediaUrl('/home/user/file.pdf')).toBe(true)
+    })
   })
 
   describe('valid media URLs with home paths', () => {
@@ -135,6 +144,11 @@ describe('needToResolveMediaUrl', () => {
       expect(needToResolveMediaUrl('~/Music/song.mp3')).toBe(true)
       expect(needToResolveMediaUrl('~/audio.wav')).toBe(true)
     })
+
+    it('should return true for home PDF paths', () => {
+      expect(needToResolveMediaUrl('~/Documents/report.pdf')).toBe(true)
+      expect(needToResolveMediaUrl('~/file.pdf')).toBe(true)
+    })
   })
 
   describe('edge cases', () => {
diff --git a/smoosense-gui/src/lib/utils/__tests__/urlUtils.test.ts b/smoosense-gui/src/lib/utils/__tests__/urlUtils.test.ts
index e5f0a31..afe8a4b 100644
--- a/smoosense-gui/src/lib/utils/__tests__/urlUtils.test.ts
+++ b/smoosense-gui/src/lib/utils/__tests__/urlUtils.test.ts
@@ -1,4 +1,4 @@
-import { getScheme, needProxy, proxyedUrl, isOnCloud } from '../urlUtils'
+import { getScheme, isOnCloud } from '../urlUtils'
 import { getFileUrl } from '../apiUtils'
 
 describe('urlUtils', () => {
@@ -42,82 +42,6 @@ describe('urlUtils', () => {
     })
   })
 
-  describe('needProxy', () => {
-    it('should return false for HTTP URLs', () => {
-      expect(needProxy('http://example.com')).toBe(false)
-    })
-
-    it('should return false for HTTPS URLs', () => {
-      expect(needProxy('https://example.com')).toBe(false)
-    })
-
-    it('should return false for URLs without scheme', () => {
-      expect(needProxy('example.com')).toBe(false)
-      expect(needProxy('/local/path')).toBe(false)
-    })
-
-    it('should return true for S3 URLs', () => {
-      expect(needProxy('s3://bucket/file.txt')).toBe(true)
-    })
-
-    it('should return true for FTP URLs', () => {
-      expect(needProxy('ftp://server/file.txt')).toBe(true)
-    })
-
-    it('should return true for file URLs', () => {
-      expect(needProxy('file:///local/path')).toBe(true)
-    })
-
-    it('should return true for custom scheme URLs', () => {
-      expect(needProxy('custom://protocol/resource')).toBe(true)
-    })
-  })
-
-  describe('proxyedUrl', () => {
-    it('should return original URL for HTTP URLs', () => {
-      const url = 'http://example.com/file.txt'
-      expect(proxyedUrl(url)).toBe(url)
-    })
-
-    it('should return original URL for HTTPS URLs', () => {
-      const url = 'https://example.com/file.txt'
-      expect(proxyedUrl(url)).toBe(url)
-    })
-
-    it('should return proxied URL for S3 URLs', () => {
-      const url = 's3://bucket/file.txt'
-      const expected = `./api/s3-proxy?url=${encodeURIComponent(url)}`
-      expect(proxyedUrl(url)).toBe(expected)
-    })
-
-    it('should return proxied URL for FTP URLs', () => {
-      const url = 'ftp://server/file.txt'
-      const expected = `./api/s3-proxy?url=${encodeURIComponent(url)}`
-      expect(proxyedUrl(url)).toBe(expected)
-    })
-
-    it('should properly encode URL parameters', () => {
-      const url = 's3://bucket/path with spaces/file.txt'
-      const expected = `./api/s3-proxy?url=${encodeURIComponent(url)}`
-      expect(proxyedUrl(url)).toBe(expected)
-    })
-
-    it('should return relative URLs unchanged when starting with ./', () => {
-      const url = './images/small.jpg'
-      expect(proxyedUrl(url)).toBe(url)
-    })
-
-    it('should return URLs unchanged when starting with /', () => {
-      const url = '/local/file.txt'
-      expect(proxyedUrl(url)).toBe(url)
-    })
-
-    it('should return URLs unchanged when starting with ~/', () => {
-      const url = '~/home/file.txt'
-      expect(proxyedUrl(url)).toBe(url)
-    })
-  })
-
   describe('getFileUrl', () => {
     it('should create file API URL with encoded path and default redirect=false', () => {
       const path = '/local/file.txt'
diff --git a/smoosense-gui/src/lib/utils/bboxUtils.ts b/smoosense-gui/src/lib/utils/bboxUtils.ts
index ab9f5a8..ec5538b 100644
--- a/smoosense-gui/src/lib/utils/bboxUtils.ts
+++ b/smoosense-gui/src/lib/utils/bboxUtils.ts
@@ -1,4 +1,5 @@
-import { CDN_URL, proxyedUrl } from './urlUtils'
+import { CDN_URL } from './urlUtils'
+import { mayResolveUrl } from './mediaUrlUtils'
 
 /**
  * Parse bbox value - must be array of 4 numbers: [x, y, width, height]
@@ -14,7 +15,8 @@ export function parseBbox(value: unknown): number[] | null {
  * Build the viz-bbox.html URL for displaying bounding boxes on an image
  * @param imageUrl - URL of the image
  * @param bboxes - Array of bbox arrays (each bbox is [x, y, width, height])
- * @param baseUrl - Base URL to prepend to proxied URLs
+ * @param tablePath - The current table path (for resolving relative paths)
+ * @param baseUrl - Base URL to prepend to resolved URLs
  * @param labels - Optional array of labels for each bbox
  * @param autorange - Whether to auto-range the visualization (default: true)
  * @returns The viz-bbox.html URL
@@ -22,6 +24,7 @@ export function parseBbox(value: unknown): number[] | null {
 export function buildBboxVizUrl(
   imageUrl: string,
   bboxes: number[][],
+  tablePath: string,
   baseUrl: string,
   labels?: string[],
   autorange: boolean = true
@@ -31,14 +34,11 @@ export function buildBboxVizUrl(
     label: labels?.[index] || ''
   }))
 
-  // Proxy the image URL and prepend baseUrl if it's a relative URL
-  const proxiedImageUrl = proxyedUrl(imageUrl)
-  const absoluteImageUrl = baseUrl && proxiedImageUrl.startsWith('./')
-    ? baseUrl + '/' + proxiedImageUrl
-    : proxiedImageUrl
+  // Resolve the image URL using the same logic as other media URLs
+  const resolvedImageUrl = mayResolveUrl({ value: imageUrl, tablePath, baseUrl })
 
   const bboxesParam = encodeURIComponent(JSON.stringify(bboxObjects))
-  const imageParam = encodeURIComponent(absoluteImageUrl)
+  const imageParam = encodeURIComponent(resolvedImageUrl)
   const autorangeParam = autorange ? 'true' : 'false'
 
   return `${CDN_URL}/viz-bbox.html?image=${imageParam}&bboxes=${bboxesParam}&autorange=${autorangeParam}`
diff --git a/smoosense-gui/src/lib/utils/cellRenderers/AudioCellRenderer.tsx b/smoosense-gui/src/lib/utils/cellRenderers/AudioCellRenderer.tsx
index 36c0ff4..47e8cc2 100644
--- a/smoosense-gui/src/lib/utils/cellRenderers/AudioCellRenderer.tsx
+++ b/smoosense-gui/src/lib/utils/cellRenderers/AudioCellRenderer.tsx
@@ -4,7 +4,7 @@ import { memo } from 'react'
 import dynamic from 'next/dynamic'
 import CellPopover from '@/components/ui/CellPopover'
 import { isNil } from 'lodash'
-import { proxyedUrl } from '@/lib/utils/urlUtils'
+import { mayResolveUrl } from '../mediaUrlUtils'
 import AudioMiniMelSpectrogram from '@/components/audio/AudioMiniMelSpectrogram'
 import { useAppSelector } from '@/lib/hooks'
 
@@ -29,8 +29,12 @@ const AudioCellRenderer = memo(function AudioCellRenderer({
   value
 }: AudioCellRendererProps) {
   const rowHeight = useAppSelector((state) => state.ui.rowHeight)
+  const tablePath = useAppSelector((state) => state.ui.tablePath)
+  const baseUrl = useAppSelector((state) => state.ui.baseUrl)
   const originalUrl = String(value).trim()
 
+  const resolvedUrl = mayResolveUrl({ value, tablePath, baseUrl })
+
   // Handle empty or invalid values
   if (isNil(value) || value === '' || !originalUrl) {
     return (
@@ -40,7 +44,7 @@ const AudioCellRenderer = memo(function AudioCellRenderer({
     )
   }
 
-  const audioUrl = proxyedUrl(originalUrl)
+  const audioUrl = resolvedUrl
 
   const cellContent = (
     <div className="w-full h-full flex items-center justify-center p-1">
diff --git a/smoosense-gui/src/lib/utils/cellRenderers/BboxCellRenderer.tsx b/smoosense-gui/src/lib/utils/cellRenderers/BboxCellRenderer.tsx
index 6095f48..df8ad30 100644
--- a/smoosense-gui/src/lib/utils/cellRenderers/BboxCellRenderer.tsx
+++ b/smoosense-gui/src/lib/utils/cellRenderers/BboxCellRenderer.tsx
@@ -17,6 +17,7 @@ const BboxCellRenderer = memo(function BboxCellRenderer({
   value,
   nodeData
 }: BboxCellRendererProps) {
+  const tablePath = useAppSelector((state) => state.ui.tablePath)
   const baseUrl = useAppSelector((state) => state.ui.baseUrl)
 
   // Handle empty or invalid values
@@ -38,12 +39,12 @@ const BboxCellRenderer = memo(function BboxCellRenderer({
     return <DefaultCellRenderer value={JSON.stringify(bbox)} type={RenderType.Text} />
   }
 
-  // Construct the viz-bbox.html URL with image URL and baseUrl
-  if (!baseUrl) {
+  // Construct the viz-bbox.html URL with image URL, tablePath, and baseUrl
+  if (!baseUrl || !tablePath) {
     return <DefaultCellRenderer value={JSON.stringify(bbox)} type={RenderType.Text} />
   }
 
-  const vizUrl = buildBboxVizUrl(imageUrl, [bbox], baseUrl)
+  const vizUrl = buildBboxVizUrl(imageUrl, [bbox], tablePath, baseUrl)
 
   // Use IFrameCellRenderer to display the viz
   return <IFrameCellRenderer value={vizUrl} />
diff --git a/smoosense-gui/src/lib/utils/cellRenderers/ImageCellRenderer.tsx b/smoosense-gui/src/lib/utils/cellRenderers/ImageCellRenderer.tsx
index b623baa..0cc3afc 100644
--- a/smoosense-gui/src/lib/utils/cellRenderers/ImageCellRenderer.tsx
+++ b/smoosense-gui/src/lib/utils/cellRenderers/ImageCellRenderer.tsx
@@ -4,6 +4,8 @@ import { memo } from 'react'
 import CellPopover from '@/components/ui/CellPopover'
 import ImageBlock from '@/components/common/ImageBlock'
 import { isNil } from 'lodash'
+import { mayResolveUrl } from '../mediaUrlUtils'
+import { useAppSelector } from '@/lib/hooks'
 
 interface ImageCellRendererProps {
   value: unknown
@@ -12,7 +14,12 @@ interface ImageCellRendererProps {
 const ImageCellRenderer = memo(function ImageCellRenderer({
   value
 }: ImageCellRendererProps) {
+  const tablePath = useAppSelector((state) => state.ui.tablePath)
+  const baseUrl = useAppSelector((state) => state.ui.baseUrl)
   const originalUrl = String(value).trim()
+  console.log('Image original url', originalUrl)
+
+  const resolvedUrl = mayResolveUrl({ value, tablePath, baseUrl })
 
   // Handle empty or invalid values
   if (isNil(value) || value === '' || !originalUrl) {
@@ -25,7 +32,7 @@ const ImageCellRenderer = memo(function ImageCellRenderer({
 
   const cellContent = (
       <ImageBlock
-        src={originalUrl}
+        src={resolvedUrl}
         alt="Image"
         className="rounded transition-opacity w-full h-full"
       />
@@ -34,7 +41,7 @@ const ImageCellRenderer = memo(function ImageCellRenderer({
   const popoverContent = (
     <div className="flex items-center justify-center h-full max-h-full">
       <ImageBlock
-        src={originalUrl}
+        src={resolvedUrl}
         alt="Full size image"
         className="object-contain max-h-full"
         neverFitCover={true}
@@ -46,7 +53,7 @@ const ImageCellRenderer = memo(function ImageCellRenderer({
     <CellPopover
       cellContent={cellContent}
       popoverContent={popoverContent}
-      url={originalUrl}
+      url={resolvedUrl}
       popoverClassName=""
       cellContentClassName="items-center justify-center"
       copyValue={originalUrl}
diff --git a/smoosense-gui/src/lib/utils/cellRenderers/PdfCellRenderer.tsx b/smoosense-gui/src/lib/utils/cellRenderers/PdfCellRenderer.tsx
index 855c373..1c2184a 100644
--- a/smoosense-gui/src/lib/utils/cellRenderers/PdfCellRenderer.tsx
+++ b/smoosense-gui/src/lib/utils/cellRenderers/PdfCellRenderer.tsx
@@ -3,16 +3,20 @@
 import { memo } from 'react'
 import { FileText } from 'lucide-react'
 import CellPopover from '@/components/ui/CellPopover'
-import { proxyedUrl } from '@/lib/utils/urlUtils'
-import {pathBasename} from "@/lib/utils/pathUtils";
+import { mayResolveUrl } from '@/lib/utils/mediaUrlUtils'
+import { pathBasename } from "@/lib/utils/pathUtils"
+import { useAppSelector } from '@/lib/hooks'
 
 interface PdfCellRendererProps {
   value: unknown
 }
 
 const PdfCellRenderer = memo(function PdfCellRenderer({ value }: PdfCellRendererProps) {
-  const originalUrl = String(value)
-  const pdfUrl = proxyedUrl(originalUrl)
+  const tablePath = useAppSelector((state) => state.ui.tablePath)
+  const baseUrl = useAppSelector((state) => state.ui.baseUrl)
+  const originalUrl = String(value).trim()
+
+  const resolvedUrl = mayResolveUrl({ value, tablePath, baseUrl })
 
   // Extract filename from URL
   const filename = pathBasename(originalUrl)
@@ -26,7 +30,7 @@ const PdfCellRenderer = memo(function PdfCellRenderer({ value }: PdfCellRenderer
 
   const popoverContent = (
     <iframe
-      src={pdfUrl}
+      src={resolvedUrl}
       className="w-full h-full border-0"
       title="PDF Preview"
     />
@@ -36,8 +40,8 @@ const PdfCellRenderer = memo(function PdfCellRenderer({ value }: PdfCellRenderer
     <CellPopover
       cellContent={cellContent}
       popoverContent={popoverContent}
-      url={pdfUrl}
-      copyValue={pdfUrl}
+      url={resolvedUrl}
+      copyValue={originalUrl}
       popoverClassName="w-[600px] h-[500px]"
     />
   )
diff --git a/smoosense-gui/src/lib/utils/cellRenderers/VideoCellRenderer.tsx b/smoosense-gui/src/lib/utils/cellRenderers/VideoCellRenderer.tsx
index adaa7aa..1e72cb2 100644
--- a/smoosense-gui/src/lib/utils/cellRenderers/VideoCellRenderer.tsx
+++ b/smoosense-gui/src/lib/utils/cellRenderers/VideoCellRenderer.tsx
@@ -4,6 +4,8 @@ import { memo } from 'react'
 import CellPopover from '@/components/ui/CellPopover'
 import VideoPlayer from '@/components/common/VideoPlayer'
 import { isNil } from 'lodash'
+import { mayResolveUrl } from '../mediaUrlUtils'
+import { useAppSelector } from '@/lib/hooks'
 
 interface VideoCellRendererProps {
   value: unknown
@@ -12,8 +14,12 @@ interface VideoCellRendererProps {
 const VideoCellRenderer = memo(function VideoCellRenderer({
   value
 }: VideoCellRendererProps) {
+  const tablePath = useAppSelector((state) => state.ui.tablePath)
+  const baseUrl = useAppSelector((state) => state.ui.baseUrl)
   const originalUrl = String(value).trim()
 
+  const resolvedUrl = mayResolveUrl({ value, tablePath, baseUrl })
+
   // Handle empty or invalid values
   if (isNil(value) || value === '' || !originalUrl) {
     return (
@@ -28,7 +34,7 @@ const VideoCellRenderer = memo(function VideoCellRenderer({
       className="relative rounded overflow-hidden bg-muted w-full h-full"
     >
       <VideoPlayer
-        src={originalUrl}
+        src={resolvedUrl}
         showControlsAtHover={false}
       />
     </div>
@@ -37,7 +43,7 @@ const VideoCellRenderer = memo(function VideoCellRenderer({
   const popoverContent = (
     <div className="relative">
       <VideoPlayer
-        src={originalUrl}
+        src={resolvedUrl}
         className=""
         alwaysAutoPlay={true}
       />
@@ -49,7 +55,7 @@ const VideoCellRenderer = memo(function VideoCellRenderer({
       cellContent={cellContent}
       cellContentClassName="items-center justify-center"
       popoverContent={popoverContent}
-      url={originalUrl}
+      url={resolvedUrl}
       copyValue={originalUrl}
     />
   )
diff --git a/smoosense-gui/src/lib/utils/mediaUrlUtils.ts b/smoosense-gui/src/lib/utils/mediaUrlUtils.ts
index 57e7370..2aae645 100644
--- a/smoosense-gui/src/lib/utils/mediaUrlUtils.ts
+++ b/smoosense-gui/src/lib/utils/mediaUrlUtils.ts
@@ -7,7 +7,7 @@ import {getFileType, FileType} from './fileTypes'
  * Returns true if:
  * - Value is a string
  * - AND starts with ./, /, ~/, or s3://
- * - AND has a media file extension (image, video, or audio)
+ * - AND has a media file extension (image, video, audio, or pdf)
  */
 export const needToResolveMediaUrl = (value: unknown): boolean => {
   // Must be a string
@@ -26,9 +26,9 @@ export const needToResolveMediaUrl = (value: unknown): boolean => {
     return false
   }
 
-  // Must be a media file
+  // Must be a media file (image, video, audio, or pdf)
   const fileType = getFileType(value)
-  return fileType === FileType.Image || fileType === FileType.Video || fileType === FileType.Audio
+  return [FileType.Image, FileType.Video, FileType.Audio, FileType.Pdf].includes(fileType)
 }
 
 /**
@@ -82,6 +82,31 @@ function resolveRelativePath(tablePath: string, relativePath: string): string {
   return pathJoin(dirPath, cleanRelative)
 }
 
+/**
+ * Conditionally resolve a media URL if needed
+ * @param params - Object containing value, tablePath, and baseUrl
+ * @param params.value - The value to check and potentially resolve
+ * @param params.tablePath - The current table path (for resolving relative paths like ./)
+ * @param params.baseUrl - The base URL to prepend (for absolute paths like / or ~/)
+ * @returns The resolved URL if resolution was needed, otherwise the original value as string
+ */
+export const mayResolveUrl = ({
+  value,
+  tablePath,
+  baseUrl
+}: {
+  value: unknown
+  tablePath: string | null
+  baseUrl: string | null
+}): string => {
+  const originalUrl = String(value).trim()
+
+  // Resolve URL if needed
+  return (tablePath && baseUrl && needToResolveMediaUrl(value))
+    ? resolveAssetUrl(originalUrl, tablePath, baseUrl)
+    : originalUrl
+}
+
 /**
  * Resolve asset URLs to full URLs, handling relative paths, absolute paths, S3 URLs, and remote URLs
  * @param url - The URL or file path to resolve
diff --git a/smoosense-gui/src/lib/utils/urlUtils.ts b/smoosense-gui/src/lib/utils/urlUtils.ts
index 7717b56..cb0833e 100644
--- a/smoosense-gui/src/lib/utils/urlUtils.ts
+++ b/smoosense-gui/src/lib/utils/urlUtils.ts
@@ -23,27 +23,9 @@ export function isUrl(str: string): boolean {
          str.startsWith('s3://') ||
          str.startsWith('ftp://') ||
          str.startsWith('file://') ||
-         str.startsWith('./')
-}
-
-export const needProxy = (url: string): boolean => {
-  const scheme = getScheme(url);
-  return !['http', 'https', ''].includes(scheme);
-}
-
-export const proxyedUrl = (url: string): string => {
-  // Assert that relative URLs should have been handled before this stage
-  if (url.startsWith('./') || url.startsWith('/') || url.startsWith('~/')) {
-    return url
-  }
-
-  // At this point, url should be an absolute URL (http://, https://, s3://, etc.)
-  if (!needProxy(url)) {
-    return url
-  } else {
-    // Proxy cloud storage URLs (s3://, etc.)
-    return `${API_PREFIX}/s3-proxy?url=${encodeURIComponent(url)}`
-  }
+         str.startsWith('./') ||
+         str.startsWith('~/') ||
+         str.startsWith('/')
 }
 
 export const isOnCloud = (fullPath: string): string => {
diff --git a/smoosense-py/smoosense/handlers/fs.py b/smoosense-py/smoosense/handlers/fs.py
index 85b08b1..6a5a92e 100644
--- a/smoosense-py/smoosense/handlers/fs.py
+++ b/smoosense-py/smoosense/handlers/fs.py
@@ -12,6 +12,7 @@
 from smoosense.exceptions import AccessDeniedException, InvalidInputException
 from smoosense.utils.api import handle_api_errors, require_arg
 from smoosense.utils.local_fs import LocalFileSystem
+from smoosense.utils.mime_types import get_mime_type
 from smoosense.utils.s3_fs import S3FileSystem
 
 logger = logging.getLogger(__name__)
@@ -26,6 +27,7 @@ def create_streaming_response(
     flask_response.headers["Access-Control-Allow-Origin"] = "*"
     flask_response.headers["Access-Control-Allow-Methods"] = "GET, POST, OPTIONS"
     flask_response.headers["Access-Control-Allow-Headers"] = "Content-Type, Authorization"
+    flask_response.headers["Content-Disposition"] = "inline"
     return flask_response
 
 
@@ -49,10 +51,6 @@ def get_file() -> Response:
     path = require_arg("path")
     redirect_param = request.args.get("redirect", "false").lower() == "true"
     ext = os.path.splitext(path)[1].lower()
-    mime_type = {
-        ".json": "application/json",
-        ".txt": "text/plain",
-    }
 
     if path.startswith("http://"):
         logger.info(f"Proxying HTTP URL {path}")
@@ -60,9 +58,7 @@ def get_file() -> Response:
             response = requests.get(path, stream=True, timeout=30)
             response.raise_for_status()
 
-            content_type = response.headers.get(
-                "content-type", mime_type.get(ext, "application/octet-stream")
-            )
+            content_type = response.headers.get("content-type", get_mime_type(ext))
 
             def generate() -> Generator[bytes, None, None]:
                 for chunk in response.iter_content(chunk_size=8192):
@@ -104,7 +100,7 @@ def generate() -> Generator[bytes, None, None]:
                             break
                         yield chunk
 
-                content_type = mime_type.get(ext, "application/octet-stream")
+                content_type = get_mime_type(ext)
                 return create_streaming_response(generate(), content_type)
             except Exception as e:
                 logger.error(f"Failed to proxy S3 file {path}: {e}")
@@ -114,11 +110,13 @@ def generate() -> Generator[bytes, None, None]:
         if path.startswith("~"):
             path = os.path.expanduser(path)
         logger.info(f"Sending file {path}")
-        file_response = send_file(path, mimetype=mime_type.get(ext, "application/octet-stream"))
+        file_response = send_file(path, mimetype=get_mime_type(ext))
         # Add CORS headers for local file responses
         file_response.headers["Access-Control-Allow-Origin"] = "*"
         file_response.headers["Access-Control-Allow-Methods"] = "GET, POST, OPTIONS"
         file_response.headers["Access-Control-Allow-Headers"] = "Content-Type, Authorization"
+        file_response.headers["Content-Disposition"] = "inline"
+
         return file_response
 
 
diff --git a/smoosense-py/smoosense/utils/mime_types.py b/smoosense-py/smoosense/utils/mime_types.py
new file mode 100644
index 0000000..d4162b1
--- /dev/null
+++ b/smoosense-py/smoosense/utils/mime_types.py
@@ -0,0 +1,66 @@
+"""Utility functions for MIME type detection."""
+
+# Comprehensive MIME type mapping for common file extensions
+MIME_TYPES = {
+    # Text formats
+    ".txt": "text/plain",
+    ".json": "application/json",
+    ".csv": "text/csv",
+    ".xml": "application/xml",
+    ".html": "text/html",
+    ".css": "text/css",
+    ".js": "application/javascript",
+    # Image formats
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".webp": "image/webp",
+    ".bmp": "image/bmp",
+    ".ico": "image/x-icon",
+    # Video formats
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+    ".avi": "video/x-msvideo",
+    ".mov": "video/quicktime",
+    ".wmv": "video/x-ms-wmv",
+    ".flv": "video/x-flv",
+    ".mkv": "video/x-matroska",
+    # Audio formats
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".ogg": "audio/ogg",
+    ".m4a": "audio/mp4",
+    ".flac": "audio/flac",
+    ".aac": "audio/aac",
+    # Document formats
+    ".pdf": "application/pdf",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".xls": "application/vnd.ms-excel",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".ppt": "application/vnd.ms-powerpoint",
+    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    # Archive formats
+    ".zip": "application/zip",
+    ".tar": "application/x-tar",
+    ".gz": "application/gzip",
+    ".7z": "application/x-7z-compressed",
+    # Data formats
+    ".parquet": "application/octet-stream",
+}
+
+
+def get_mime_type(file_extension: str, default: str = "application/octet-stream") -> str:
+    """
+    Get the MIME type for a given file extension.
+
+    Args:
+        file_extension: The file extension (e.g., '.pdf', '.jpg')
+        default: Default MIME type if extension is not recognized
+
+    Returns:
+        The MIME type string
+    """
+    return MIME_TYPES.get(file_extension.lower(), default)