# Audio MCP (pypi · audio-mcp)

Audio perception for AI agents: measure, see, compare, edit and synthesize sound locally.

- Trust score: 74/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-10-17

## Components

- pypi · `audio-mcp`: 74/100 (this document), [markdown](https://verifymcp.io/servers/mshark1-audio-mcp/audio-mcp.md), [page](https://verifymcp.io/servers/mshark1-audio-mcp/audio-mcp)

## Channel facts

- Registry: `pypi`
- Package: `audio-mcp`
- Version: `0.4.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-10-17.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs setuptools.build_meta at install time, a recognised build step with no custom scripting around it.
  - 3 of 43 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 97/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to mshark1/audio-mcp).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 0 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 51/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 3043 tokens (~217/item across 14 items; 14 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability observed for 0 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 67/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 0% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 14 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 15 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the Audio MCP server?

Audio MCP runs locally as a PyPI package, launched with uvx audio-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add mshark1-audio-mcp -- uvx audio-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "mshark1-audio-mcp": {
      "command": "uvx",
      "args": [
        "audio-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "mshark1-audio-mcp": {
      "command": "uvx",
      "args": [
        "audio-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add mshark1-audio-mcp -- uvx audio-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "mshark1-audio-mcp": {
      "type": "local",
      "command": [
        "uvx",
        "audio-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add mshark1-audio-mcp --command uvx --arg audio-mcp
```

### Hermes

```yaml
mcp_servers:
  mshark1-audio-mcp:
    command: "uvx"
    args: ["audio-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "mshark1-audio-mcp": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "audio-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add mshark1-audio-mcp -t stdio -c uvx -a audio-mcp
```

### Other

```json
{
  "mcpServers": {
    "mshark1-audio-mcp": {
      "command": "uvx",
      "args": [
        "audio-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-10-17 (score 74, +25)

- [security improvement] Injection markers: unverified → pass
- [security] First check of Judged manipulation: pass
- [security] Tool safety: Tool safety not yet verified: we do not have a sandbox capture of the tool definitions this version of the package serves yet.
- [security] Stability: Stability not yet verified: we do not have a sandbox capture of the MCP schema this version of the package serves yet.
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] Stability: unverified → 0.00
- [functional improvement] MCP protocol: unverified → pass
- [functional] First check of Tool coverage: 0
- [functional] First check of Schema quality: fail
- [functional] First check of Destructive annotations: pass
- [functional] First check of Schema quality: fail
- [functional] First check of Schema quality: good
- [functional] Capabilities: Protocol version not yet verified: we do not have a sandbox capture of the MCP handshake this version of the package performs yet.
- [functional] Tool coverage: Tool coverage not yet verified: we do not have a sandbox capture of the tool definitions this version of the package serves yet.
- [functional] Schema quality: Schema quality not yet verified: we do not have a sandbox capture of the MCP schema this version of the package serves yet.
- [functional] Package version: 0.3.0 → 0.4.0

### 2026-10-15 (score 49, 0)

- [security] Stability: Stability not yet verified: this server's registry entry declares environment variables (an API key or similar), and its server did not start in our sandbox, so we have no schema to compare.
- [security] Tool safety: Tool safety not yet verified: this server's registry entry declares environment variables (an API key or similar), and its server did not start in our sandbox, so we have no tool text to scan.
- [functional] Schema quality: Schema quality not yet verified: this server's registry entry declares environment variables (an API key or similar), and its server did not start in our sandbox, so we have no schema to assess.
- [functional] Capabilities: Protocol version not yet verified: this server's registry entry declares environment variables (an API key or similar), and its server did not start in our sandbox, so we never saw its MCP handshake.
- [functional] Tool coverage: Tool coverage not yet verified: this server's registry entry declares environment variables (an API key or similar), and its server did not start in our sandbox, so we have no tool definitions to assess.

### 2026-10-14 (score 49, 0)

- [functional] Package version: 0.1.1 → 0.3.0
- [functional] Package version: 0.1.1 → 0.2.0

### 2026-10-13 (score 49)

First indexed and scored.

## MCP tools (14)

### `audio_info` (~100 tokens)

Fast metadata without decoding: format, sample rate, channels, duration.
Files read through FFmpeg (M4A/AAC, WMA, MP4/MOV/WebM/MKV video) report decoded_via="ffmpeg", the container
as format and the codec as subtype; without FFmpeg they fail with install instructions.
If `path` is a directory, lists the audio files inside it (recursively).

Input parameters:

- `path` (string, required)

### `audio_analyze` (~146 tokens)

Measure an audio file (or the start..end section): peak/true-peak/RMS/LUFS loudness, clipping, DC offset,
a loudness sparkline over time, silence and noise floor, stereo correlation/width/balance, spectral balance
(band energy, brightness, tonal vs noisy, strongest frequencies as notes), pitch, onsets/tempo,
start/end clicks and loop-seam quality. Ends with `issues`: plain-language problems ranked by severity.
Set pitch/rhythm to false to run faster.

Input parameters:

- `end`
- `path` (string, required)
- `pitch` (boolean)
- `rhythm` (boolean)
- `start`

### `audio_timeline` (~78 tokens)

How the sound changes over time: per-segment RMS, peak and brightness, plus a loudness sparkline.
Streams the file, so it works on recordings of any length; use it to find where to zoom in.

Input parameters:

- `end`
- `path` (string, required)
- `segments` (integer)
- `start`

### `audio_view` (~170 tokens)

Render a picture of the sound. kind: 'both' (waveform above spectrogram), 'waveform' or 'spectrogram'.
Spectrogram: time left to right, frequency bottom to top, brighter = louder. Horizontal lines are pitched
tones/harmonics, vertical stripes are clicks/transients, diffuse haze is noise. Red dashed lines on the
waveform mark 0 dBFS (clipping). Zoom with start/end; pitch_overlay draws the detected f0 in cyan.
save_to optionally also writes the PNG to disk.

Input parameters:

- `end`
- `freq_scale` (string)
- `kind` (string)
- `max_freq`
- `path` (string, required)
- `pitch_overlay` (boolean)
- `save_to`
- `start`

### `audio_melody` (~116 tokens)

Transcribe a monophonic line (voice, whistle, solo instrument, synth lead, SFX pitch) into notes with
start times, durations, note names and cents deviation, plus a compact text form.
Narrow fmin/fmax to the expected range for better accuracy (e.g. bass 40-400, voice 80-1000).

Input parameters:

- `end`
- `fmax` (number)
- `fmin` (number)
- `path` (string, required)
- `start`

### `audio_events` (~178 tokens)

Split the audio into distinct sound events (hits, notes, words/syllables, SFX layers) and describe each:
start/end, level, attack, tonal vs noisy, brightness, pitch and pitch glide. `as_text` gives one line per
event, e.g. "0.52-0.81s | -14dB | tonal | bright | A5 glide -12st | sharp attack". Also reports spacing
regularity and the sequence of pitches. The threshold adapts to the background level; set threshold_db
(dBFS) to override. split_on_onsets=false keeps continuous sounds (e.g. a sentence) as one event.

Input parameters:

- `end`
- `path` (string, required)
- `split_on_onsets` (boolean)
- `start`
- `threshold_db`

### `audio_transcribe` (~160 tokens)

Speech to text (Whisper, runs locally). Returns the text, timed segments, per-word timings with
confidence, detected language, speaking rate, long pauses and `uncertain_words` (likely mis-hearings).
model: tiny/base/small/medium/large-v3/turbo (bigger = more accurate, slower; first use downloads it).
language: ISO code like "en" to skip detection. initial_prompt: names or jargon to help spelling.
Use start/end to transcribe part of a long recording.

Input parameters:

- `end`
- `initial_prompt`
- `language`
- `model` (string)
- `path` (string, required)
- `start`
- `word_timestamps` (boolean)

### `audio_batch_survey` (~105 tokens)

Analyze a folder (recursive; filter with a glob `pattern` like "*.wav" or "footstep*") or a list of
files, and report how consistent they are: loudness outliers, mixed sample rates/channels/formats,
inconsistent leading silence, files with problems. Includes `suggested_fixes` with ready-to-use
operations for audio_batch_process, and a per-file table.

Input parameters:

- `pattern` (string)
- `target` (required)

### `audio_batch_process` (~189 tokens)

Apply one operations chain (same format as audio_process) to every file in a folder or list, writing
results with the same relative names into output_dir. Refuses to write into the input folder unless
overwrite=true. Example: normalize a set of sound effects to the same loudness:
[{"op":"trim_silence"}, {"op":"normalize_lufs","lufs":-18,"limit":true}].
subtype: sample format for every output, e.g. PCM_16, PCM_24, FLOAT, or PCM_U8 for 8-bit WAV (retro or
low-memory targets: combine with to_mono and resample). Checked before any file is written.

Input parameters:

- `operations` (array, required)
- `output_dir` (string, required)
- `overwrite` (boolean)
- `pattern` (string)
- `subtype`
- `target` (required)

### `audio_compare` (~108 tokens)

A/B two files: plain-language summary, metric deltas (loudness, peak, brightness, tempo, pitch),
per-band level changes, spectral-shape similarity, issues fixed or introduced, and a null test
(aligns and subtracts) that tells whether B is identical, gain-changed, lightly or heavily changed.
Use after audio_process to verify an edit did what you intended and nothing else.

Input parameters:

- `path_a` (string, required)
- `path_b` (string, required)

### `audio_process` (~413 tokens)

Apply operations in order and write a NEW file (default: <name>_processed.<ext> next to the input;
the input is never modified unless output==path and overwrite=true; M4A/video inputs default to WAV output). Each operation is an object, e.g.
[{"op":"highpass","hz":80}, {"op":"normalize_lufs","lufs":-16}, {"op":"fade_out","seconds":0.5}].
Ops: gain(db) normalize_peak(db=-1, true_peak=false) normalize_rms(db=-20)
normalize_lufs(lufs=-16, ceiling_db=-1, limit=false, measure=integrated|momentary_max) trim_silence(threshold_db=-60, pad_ms=10)
denoise(reduction_db=12, sensitivity=1, noise_start, noise_end) [verify speech afterwards with audio_transcribe]
limit(ceiling_db=-1, release_ms=60, lookahead_ms=5) compress(threshold_db=-18, ratio=3, attack_ms=10, release_ms=120, knee_db=6, makeup_db=0)
fade_in/fade_out(seconds, curve=cosine|linear|equal_power) crop(start, end) pad(start, end)
highpass/lowpass(hz, order=4) eq(hz, db, q=1) low_shelf/high_shelf(hz, db) remove_dc to_mono to_stereo
resample(rate) reverse polarity(channel=None) loop_crossfade(seconds=0.05) mix(path, at=0, gain_db=0) append(path, gap=0).
subtype: e.g. PCM_16, PCM_24, FLOAT, PCM_U8 (8-bit) for WAV. Returns before/after levels and any warnings.

Input parameters:

- `operations` (array, required)
- `output`
- `overwrite` (boolean)
- `path` (string, required)
- `subtype`

### `audio_synthesize` (~520 tokens)

Generate audio from a declarative spec: tones, sweeps, chords, noise bursts, simple melodies and
layered sound effects (band-limited oscillators, ADSR envelopes, vibrato, tremolo, filters, panning).
Example laser zap: {"layers":[{"wave":"square","freq":1800,"freq_end":200,"duration":0.25,
"envelope":{"attack":0.002,"release":0.1},"lowpass":6000}]}.
Example melody: {"layers":[{"wave":"triangle","sequence":[["C4",0.25],["E4",0.25],["G4",0.5]]}]}.
Full schema:
spec = {
  "sample_rate": 44100, "duration": <seconds, default: end of last layer>, "normalize_peak_db": -1 (null to skip),
  "layers": [{
    "wave": "sine|square|saw|triangle|noise|pink|brown|impulse|dc|silence",
        # pink/brown are generated circularly, so they loop seamlessly as-is.
        # impulse: one full-scale sample at the layer start, or a train with "freq" impulses per second.
        # dc: a constant offset (level set by gain_db; 0 dB = +1.0). silence: exact zeros.
    "freq": 440 or "A4", "freq_end": <optional sweep target>, "sweep": "exp|linear", "phase": <start phase, degrees>,
    "start": 0, "duration": <seconds>, "gain_db": 0, "pan": -1..1,
    "envelope": {"attack": 0.005, "decay": 0, "sustain": 1, "release": 0.01},
    "vibrato": {"rate_hz": 5, "depth_cents": 20}, "tremolo": {"rate_hz": 6, "depth": 0.5},
    "lowpass": <hz>, "highpass": <hz>,
    "sequence": [["C4", 0.25], ["rest", 0.25], ["E4", 0.5]]   # optional: one note per item, played back to back
  }]
}

Input parameters:

- `output` (string, required)
- `overwrite` (boolean)
- `spec` (object, required)

### `audio_check_delivery` (~186 tokens)

Check a file against a delivery spec and get a verdict (pass / pass with warnings / fail), one entry per
criterion (required, measured, status, note), and `fix`: an ordered audio_process operations list that was
simulated on this file (`fix.verified`), plus `cannot_fix` for problems no processing can solve (clipping,
a noise floor too high to remove without damaging speech, wrong length).
Specs: apple_podcasts, spotify, youtube, ebu_r128, atsc_a85, acx_audiobook, game_sfx
(spec="list" describes them). Each result cites its sources and the date they were checked.
After a fix that includes denoise, verify the words with audio_transcribe.

Input parameters:

- `end`
- `path` (string, required)
- `spec` (string, required)
- `start`

### `audio_check_game_project` (~331 tokens)

Audit the audio of a Godot 4 project (the folder with project.godot): inventory of every .wav/.ogg/.mp3 with
a category (ui, sfx, voice, music, ambience, inferred from folder/file names; override with `categories`,
e.g. {"audio/stingers": "music", "*/click_*": "ui"}), import settings from the .import files (music/ambience
that doesn't loop, SFX/UI that do, clicky loop seams, never-imported files), loudness consistency per
category (one-shots by LUFS momentary max, music/ambience by integrated LUFS; outliers, median, spread),
per-file problems (clipping, leading silence, clicky ends, DC offset, mixed sample rates, stereo SFX) and
res:// references in .tscn/.tres/.gd/.cs files (broken paths, wrong letter case, unreferenced files).
Returns `summary`, per-category `categories` stats with `suggested_batch` for audio_batch_process, and
\`issues` sorted problem > warning > info, each with a res:// file and a `fix` (audio_process operations or
an editor step). res://x means <project_dir>/x. Read-only: never modifies the project.
Analyzes at most max_files files, each over its first max_seconds (loop seams use the real loop points).

Input parameters:

- `categories`
- `max_files` (integer)
- `max_seconds` (number)
- `project_dir` (string, required)

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/mshark1-audio-mcp/audio-mcp#diagnostics

## Score history

- 2026-10-17: 74
- 2026-10-16: 49
- 2026-10-15: 49
- 2026-10-14: 49
- 2026-10-13: 49

## Common questions

### What is the Audio MCP server?

Audio MCP is listed in the public MCP registry as io.github.mshark1/audio-mcp. Audio perception for AI agents: measure, see, compare, edit and synthesize sound locally. This page covers its PyPI package (audio-mcp).

### Is the Audio MCP server safe to use?

Audio MCP scores 74 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 17 October 2026. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Audio MCP server expose?

Audio MCP exposes 14 tools: audio_info, audio_analyze, audio_timeline, audio_view, audio_melody, and 9 more. Their descriptions and schemas cost roughly 2,800 tokens of context every time the server is loaded.

### Is the Audio MCP server still maintained?

Audio MCP is still listed as active in the MCP registry. We last reached this channel on 17 October 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the Audio MCP server under?

Audio MCP declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- PyPI project: https://pypi.org/project/audio-mcp/
- Socket report: https://socket.dev/pypi/package/audio-mcp
- Repository: https://github.com/mshark1/audio-mcp
- Changelog RSS feed: https://verifymcp.io/servers/mshark1-audio-mcp/audio-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/mshark1-audio-mcp/audio-mcp.json
- HTML version of this page: https://verifymcp.io/servers/mshark1-audio-mcp/audio-mcp