How to Use Epidemic Sound MCP with Claude: AI-Powered Music Discovery for Developers

"Find upbeat electronic tracks for a mobile puzzle game"
"Search for calm, ambient music with piano, around 80 BPM"
"I need tense orchestral music for a boss battle scene"
"Find short 10-second loops suitable for UI interactions"

# Verify installation
node --version
npm --version

# Install Claude Code globally
npm install -g @anthropic-ai/claude-code

# Verify installation
claude --version

# Add the Epidemic Sound MCP server with user scope
claude mcp add epidemicsound --scope user

{
  "mcpServers": {
    "epidemicsound": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-epidemicsound"],
      "env": {
        "EPIDEMIC_SOUND_CLIENT_ID": "your-client-id",
        "EPIDEMIC_SOUND_CLIENT_SECRET": "your-client-secret"
      }
    }
  }
}

# List all configured MCP servers
claude mcp list

# Check the Epidemic Sound connection
claude mcp get epidemicsound

# If using Claude Code, simply start a new session
claude

You: Find energetic rock tracks for a racing game

Claude: I found several tracks that would work well for a racing game:

1. "Full Throttle" by Horizon Blue
   - Genre: Rock/Alternative
   - BPM: 140
   - Duration: 3:24
   - Mood: Energetic, Driving

2. "Speed Demon" by Electric Avenue
   - Genre: Hard Rock
   - BPM: 155
   - Duration: 2:58
   - Mood: Intense, Powerful

[Preview links and download options...]

You: I'm building a memory matching game for kids. I need 8 distinct
short musical clips that are easy to remember and differentiate.
Each should be about 5-10 seconds, family-friendly, and cover
different musical styles.

Claude: Here are 8 distinct clips perfect for a memory game:

1. Classical Piano Melody - Gentle, recognizable tune
2. Upbeat Ukulele Strum - Happy, playful feel
3. Jazz Saxophone Riff - Smooth, memorable hook
4. Electronic Synth Pulse - Modern, catchy beat
5. Acoustic Guitar Fingerpicking - Warm, folk-style
6. Orchestral Strings Swell - Dramatic, cinematic
7. Reggae Bass Groove - Relaxed, rhythmic pattern
8. Flute & Harp Fantasy - Magical, whimsical tone

Each clip has been selected for maximum memorability and distinction...

You: Search for UI sound effects - button clicks, success chimes,
and error sounds for a mobile app

Claude: Found these UI sound effects:

Button Clicks:
- "Soft Click" - Subtle, modern feel
- "Mechanical Press" - Tactile feedback sound
- "Digital Tap" - Clean, minimalist

Success Sounds:
- "Achievement Unlocked" - Celebratory chime
- "Level Complete" - Uplifting melody
- "Coin Collect" - Classic game feedback

Error/Alert Sounds:
- "Gentle Warning" - Non-intrusive alert
- "Soft Buzz" - Subtle error indicator
- "Try Again" - Encouraging tone

# music_config.py

from dataclasses import dataclass
from datetime import timedelta
from typing import List


@dataclass
class MusicTrack:
    id: str
    title: str
    artist: str
    file_path: str
    duration: timedelta


# Tracks discovered via Epidemic Sound MCP
GAME_MUSIC_TRACKS: List[MusicTrack] = [
    MusicTrack(
        id="track_001",
        title="Puzzle Master",
        artist="Ambient Keys",
        file_path="assets/sounds/music/puzzle_master.mp3",
        duration=timedelta(seconds=12),
    ),
    MusicTrack(
        id="track_002",
        title="Mind Games",
        artist="Electronic Dreams",
        file_path="assets/sounds/music/mind_games.mp3",
        duration=timedelta(seconds=10),
    ),
    # ... more tracks
]


# FastAPI endpoint example
from fastapi import FastAPI
from fastapi.responses import FileResponse

app = FastAPI()


@app.get("/api/tracks")
async def get_tracks():
    return [
        {
            "id": track.id,
            "title": track.title,
            "artist": track.artist,
            "duration_seconds": track.duration.total_seconds(),
        }
        for track in GAME_MUSIC_TRACKS
    ]


@app.get("/api/tracks/{track_id}/stream")
async def stream_track(track_id: str):
    track = next((t for t in GAME_MUSIC_TRACKS if t.id == track_id), None)
    if track:
        return FileResponse(track.file_path, media_type="audio/mpeg")
    return {"error": "Track not found"}

<!-- components/MusicPlayer.vue -->
<template>
  <UCard>
    <template #header>
      <div class="flex items-center justify-between">
        <h3 class="text-lg font-semibold">{{ currentTrack?.title }}</h3>
        <UBadge color="primary">{{ currentTrack?.artist }}</UBadge>
      </div>
    </template>

    <div class="space-y-4">
      <!-- Progress bar -->
      <UProgress :value="progress" />

      <!-- Controls -->
      <div class="flex items-center justify-center gap-4">
        <UButton
          icon="i-heroicons-backward"
          color="gray"
          variant="ghost"
          @click="previousTrack"
        />
        <UButton
          :icon="isPlaying ? 'i-heroicons-pause' : 'i-heroicons-play'"
          size="lg"
          @click="togglePlay"
        />
        <UButton
          icon="i-heroicons-forward"
          color="gray"
          variant="ghost"
          @click="nextTrack"
        />
      </div>

      <!-- Track list -->
      <UDivider />
      <div class="space-y-2">
        <UButton
          v-for="track in tracks"
          :key="track.id"
          block
          :color="currentTrack?.id === track.id ? 'primary' : 'gray'"
          variant="soft"
          @click="selectTrack(track)"
        >
          {{ track.title }} - {{ track.artist }}
        </UButton>
      </div>
    </div>
  </UCard>
</template>

<script setup lang="ts">
interface MusicTrack {
  id: string
  title: string
  artist: string
  src: string
  category: string
  mood: string
  bpm: number
}

// Tracks curated via Epidemic Sound MCP
const tracks: MusicTrack[] = [
  {
    id: 'es_001',
    title: 'Digital Sunrise',
    artist: 'Synth Wave Collective',
    src: '/audio/music/digital_sunrise.mp3',
    category: 'electronic',
    mood: 'uplifting',
    bpm: 120,
  },
  {
    id: 'es_002',
    title: 'Ocean Breeze',
    artist: 'Ambient Nature',
    src: '/audio/music/ocean_breeze.mp3',
    category: 'ambient',
    mood: 'calm',
    bpm: 70,
  },
]

const currentTrack = ref<MusicTrack | null>(tracks[0])
const isPlaying = ref(false)
const progress = ref(0)
const audio = ref<HTMLAudioElement | null>(null)

onMounted(() => {
  audio.value = new Audio()
  audio.value.addEventListener('timeupdate', updateProgress)
  audio.value.addEventListener('ended', nextTrack)
})

function updateProgress() {
  if (audio.value) {
    progress.value = (audio.value.currentTime / audio.value.duration) * 100
  }
}

function selectTrack(track: MusicTrack) {
  currentTrack.value = track
  if (audio.value) {
    audio.value.src = track.src
    audio.value.play()
    isPlaying.value = true
  }
}

function togglePlay() {
  if (!audio.value || !currentTrack.value) return

  if (isPlaying.value) {
    audio.value.pause()
  } else {
    if (!audio.value.src) {
      audio.value.src = currentTrack.value.src
    }
    audio.value.play()
  }
  isPlaying.value = !isPlaying.value
}

function nextTrack() {
  const currentIndex = tracks.findIndex(t => t.id === currentTrack.value?.id)
  const nextIndex = (currentIndex + 1) % tracks.length
  selectTrack(tracks[nextIndex])
}

function previousTrack() {
  const currentIndex = tracks.findIndex(t => t.id === currentTrack.value?.id)
  const prevIndex = currentIndex === 0 ? tracks.length - 1 : currentIndex - 1
  selectTrack(tracks[prevIndex])
}
</script>

// services/musicService.ts

interface MusicTrack {
  id: string
  title: string
  artist: string
  filePath: string
  mood: string
  bpm: number
  duration: number
}

interface SearchFilters {
  mood?: string
  minBpm?: number
  maxBpm?: number
  category?: string
}

class MusicService {
  private tracks: MusicTrack[] = []
  private audioContext: AudioContext | null = null
  private currentSource: AudioBufferSourceNode | null = null

  constructor() {
    // Tracks curated via Epidemic Sound MCP
    this.tracks = [
      {
        id: 'puzzle_001',
        title: 'Puzzle Master',
        artist: 'Ambient Keys',
        filePath: '/audio/puzzle_master.mp3',
        mood: 'calm',
        bpm: 85,
        duration: 120,
      },
      {
        id: 'action_001',
        title: 'Speed Runner',
        artist: 'Electric Dreams',
        filePath: '/audio/speed_runner.mp3',
        mood: 'energetic',
        bpm: 140,
        duration: 180,
      },
    ]
  }

  searchTracks(filters: SearchFilters): MusicTrack[] {
    return this.tracks.filter(track => {
      if (filters.mood && track.mood !== filters.mood) return false
      if (filters.minBpm && track.bpm < filters.minBpm) return false
      if (filters.maxBpm && track.bpm > filters.maxBpm) return false
      return true
    })
  }

  async playTrack(trackId: string): Promise<void> {
    const track = this.tracks.find(t => t.id === trackId)
    if (!track) throw new Error('Track not found')

    if (!this.audioContext) {
      this.audioContext = new AudioContext()
    }

    // Stop current playback
    this.stop()

    const response = await fetch(track.filePath)
    const arrayBuffer = await response.arrayBuffer()
    const audioBuffer = await this.audioContext.decodeAudioData(arrayBuffer)

    this.currentSource = this.audioContext.createBufferSource()
    this.currentSource.buffer = audioBuffer
    this.currentSource.connect(this.audioContext.destination)
    this.currentSource.start()
  }

  stop(): void {
    if (this.currentSource) {
      this.currentSource.stop()
      this.currentSource = null
    }
  }

  getRandomTrack(mood?: string): MusicTrack {
    const filtered = mood
      ? this.tracks.filter(t => t.mood === mood)
      : this.tracks
    return filtered[Math.floor(Math.random() * filtered.length)]
  }
}

export const musicService = new MusicService()

"Find music for my game"

"Find calm, ambient music for the menu screen of a puzzle game
 targeted at adults. Should feel modern and minimalist,
 around 70-90 BPM, with soft synths or piano."

"Find tracks that are both mysterious AND playful -
like exploring a whimsical haunted house"

"I like this track. Can you find 5 similar tracks
that would work well together as a playlist?"

"Find tracks that loop seamlessly, are exactly 30 seconds long,
and have no vocals - suitable for background gameplay music"

# Debug MCP connections
claude --mcp-debug

# Check if the server is properly configured
claude mcp list