# Engine DJ Library Assistant (unofficial) (npm · engine-dj-mcp)

Ask AI about your Engine DJ library: BPM/key search, audits, cues, opt-in playlist and tag edits.

- Trust score: 71/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-25

## Components

- npm · `engine-dj-mcp`: 71/100 (this document), [markdown](https://verifymcp.io/servers/venut-technologies-engine-dj-mcp/engine-dj-mcp.md), [page](https://verifymcp.io/servers/venut-technologies-engine-dj-mcp/engine-dj-mcp)

## Channel facts

- Registry: `npm`
- Package: `engine-dj-mcp`
- Version: `0.17.2`
- 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-09-25.

- **Supply Chain Security**: 98/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 31 of 96 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 97/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to Venut-Technologies/engine-dj-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**: 35/100
  - 0% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 2975 tokens (~270/item across 11 items; 9 tools + 2 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 74/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 22% 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 9 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 10 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 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 Engine DJ Library Assistant (unofficial) MCP server?

Engine DJ Library Assistant (unofficial) runs locally as an npm package, launched with npx -y engine-dj-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 venut-technologies-engine-dj-mcp -- npx -y engine-dj-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "venut-technologies-engine-dj-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "engine-dj-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "venut-technologies-engine-dj-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "engine-dj-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add venut-technologies-engine-dj-mcp -- npx -y engine-dj-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "venut-technologies-engine-dj-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "engine-dj-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add venut-technologies-engine-dj-mcp --command npx --arg -y --arg engine-dj-mcp
```

### Hermes

```yaml
mcp_servers:
  venut-technologies-engine-dj-mcp:
    command: "npx"
    args: ["-y", "engine-dj-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "venut-technologies-engine-dj-mcp": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "engine-dj-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add venut-technologies-engine-dj-mcp -t stdio -c npx -a -y engine-dj-mcp
```

### Other

```json
{
  "mcpServers": {
    "venut-technologies-engine-dj-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "engine-dj-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-09-24 (score 71)

First indexed and scored.

## MCP tools (9)

### `search_tracks` (~447 tokens)

Search tracks

Search the Engine DJ library by text, tempo, key, rating, play history and analysis flags. Set include_total for a count alongside the page: it is capped at 1000, and a capped result comes back as total: 1000 with total_capped: true -- treat that as 'at least 1000', never as an exact count. flags.has_cues means a hot cue is actually set (the blob is decoded when the index is built), not merely that Engine analysed the track; flags.has_beatgrid means a beatData blob is present. playlist: {id} or {name} narrows the search to one playlist -- results still come back by relevance or id, not in playlist order; use get_playlist_tracks for that. With more than one library connected, pass `library` (a uuid or path from list_libraries, either the ~/... form or the absolute one) to choose which one; the default is the supported library with the most tracks.

Input parameters:

- `added` (object)
- `bpm` (object)
- `cursor` (string)
- `fields` (array)
- `flags` (object)
- `include_total` (boolean)
- `key` (object)
- `library` (string): Which library to use: either the uuid or the path reported by list_libraries (the reported ~/... form is accepted, as is the absolute path). Omit it to use the supported library holding the most trac…
- `limit` (integer)
- `played` (object)
- `playlist` (object)
- `q` (string)
- `rating` (object)
- `redact_paths` (boolean)

### `get_tracks` (~235 tokens)

Get tracks by id

Fetch full metadata for specific track ids, in the order requested. With more than one library connected, pass `library` (a uuid or path from list_libraries, either the ~/... form or the absolute one) to choose which one; the default is the supported library with the most tracks.

Input parameters:

- `fields` (array)
- `ids` (array, required)
- `library` (string): Which library to use: either the uuid or the path reported by list_libraries (the reported ~/... form is accepted, as is the absolute path). Omit it to use the supported library holding the most trac…
- `redact_paths` (boolean)

### `get_playlists` (~380 tokens)

List playlists

The library's playlist tree, in the order Engine DJ displays it -- taken from the Playlist.nextListId chain, which is where that order actually lives (the PlaylistPath view's `position` column runs the other way). Flat and in pre-order, so reading top to bottom is exactly the sidebar: `depth` and `path` carry the nesting, `parent_id` names the folder. is_folder means the list has child lists (Engine has no folder flag; a folder is a playlist other playlists sit under), so an emptied folder reads as an empty playlist. track_count is entries in that list alone, never rolled up from children, and missing_count is how many of them name a track that is not in this library. `warnings` appears when a link chain is broken or cyclic; nothing is ever dropped from the list because of one. With more than one library connected, pass `library` (a uuid or path from list_libraries, either the ~/... form or the absolute one) to choose which one; the default is the supported library with the most tracks.

Input parameters:

- `library` (string): Which library to use: either the uuid or the path reported by list_libraries (the reported ~/... form is accepted, as is the absolute path). Omit it to use the supported library holding the most trac…
- `limit` (integer)

### `get_playlist_tracks` (~451 tokens)

Get the tracks in a playlist

The tracks of one playlist, in playlist order -- from the PlaylistEntity.nextEntityId chain, not from row ids, so a track dragged up the list comes back where the DJ put it. Name the playlist with playlist_id, or with playlist_name (exactly one of the two). A name that matches several playlists is refused with every candidate's id and full path rather than picked between -- names are unique only within a folder, so pass the full `path` from get_playlists to disambiguate. Each row carries `position`, its 1-based place in the playlist. An entry whose track is not in this library comes back as { position, entry_id, track_id, missing: true } and keeps its slot, so entry_count still matches the playlist's own length; missing_count says how many of those there are. That is ordinary, not corruption -- entries outlive their tracks and arrive from other drives (see audit_library's orphan_entries). Same fields, limit and cursor conventions as search_tracks. With more than one library connected, pass `library` (a uuid or path from list_libraries, either the ~/... form or the absolute one) to choose which one; the default is the supported library with the most tracks.

Input parameters:

- `cursor` (string)
- `fields` (array)
- `library` (string): Which library to use: either the uuid or the path reported by list_libraries (the reported ~/... form is accepted, as is the absolute path). Omit it to use the supported library holding the most trac…
- `limit` (integer)
- `playlist_id` (integer)
- `playlist_name` (string)
- `redact_paths` (boolean)

### `get_track_performance` (~448 tokens)

Get cues, loops and beatgrid

Decode PerformanceData for one track: hot cues, the main cue, saved loops, the beatgrid and a coarse waveform profile. Each field carries its own decode status and its own layout marker. layout: "verified" (every field) means the binary layout was confirmed against a real Engine DJ library -- cue positions land inside the track, the beatgrid's implied tempo matches the analysed BPM, the waveform's declared point spacing multiplies back out to the track's sample count, and a saved loop spans a whole number of beats at that same analysed BPM -- so status: "ok" is a claim about the values, not just about the parse. layout: "unverified" would mean only that the bytes parsed; no field returns it today. Positions are sample offsets; sample_rate at the top level converts them to seconds, and cue/loop items carry the seconds already. Only hot-cue and loop slots that hold something are listed -- slots is how many the track has in total, so items: [] with slots: 8 means an analysed track with no cues set. Items are capped at 64; total gives the full count and truncated says whether the cap was hit. With more than one library connected, pass `library` (a uuid or path from list_libraries, either the ~/... form or the absolute one) to choose which one; the default is the supported library with the most tracks.

Input parameters:

- `id` (integer, required)
- `library` (string): Which library to use: either the uuid or the path reported by list_libraries (the reported ~/... form is accepted, as is the absolute path). Omit it to use the supported library holding the most trac…

### `audit_library` (~387 tokens)

Audit the collection

Run collection health checks. Available: missing_files, unavailable, unanalyzed, no_cues, no_beatgrid, missing_key, suspicious_bpm, duplicates, empty_metadata, orphan_entries, path_form_mismatch. missing_files resolves each track against the selected library's own folder. path_form_mismatch finds files that are there, but under a name in a different Unicode normalization form from the stored path -- macOS opens them anyway, Linux does not (measured on its exFAT driver), and Engine OS on a player is Linux, so these may fail to load on hardware while missing_files on a Mac reports nothing. no_cues means "no hot cue is set" -- the quickCues blob is decoded for this, since Engine writes one to every analysed track whether or not a pad is used -- while no_beatgrid means the beatData blob is absent or empty. With more than one library connected, pass `library` (a uuid or path from list_libraries, either the ~/... form or the absolute one) to choose which one; the default is the supported library with the most tracks.

Input parameters:

- `checks` (array)
- `library` (string): Which library to use: either the uuid or the path reported by list_libraries (the reported ~/... form is accepted, as is the absolute path). Omit it to use the supported library holding the most trac…

### `run_sql` (~282 tokens)

Run a read-only SQL query

Escape hatch for questions the other tools do not cover. Read-only is enforced by the kernel, not by this check alone. Use side.track_derived.camelot and side.track_derived.tempo in WHERE clauses rather than the camelot()/tempo() SQL functions, which run per row and defeat indexes. With more than one library connected, pass `library` (a uuid or path from list_libraries, either the ~/... form or the absolute one) to choose which one; the default is the supported library with the most tracks.

Input parameters:

- `library` (string): Which library to use: either the uuid or the path reported by list_libraries (the reported ~/... form is accepted, as is the absolute path). Omit it to use the supported library holding the most trac…
- `limit` (integer)
- `params` (array)
- `sql` (string, required)

### `list_libraries` (~126 tokens)

List Engine DJ libraries

List every discovered library, including ones whose schema is unsupported. Re-scans on every call, so a drive plugged in after this server started is visible without a restart (the engine://libraries resource is a start-time snapshot). A library seen before but not readable right now (e.g. Engine DJ is writing to it) stays listed with status: "unreadable" and error set, instead of disappearing. Pass a listed uuid or path as the `library` argument of any other tool to act on that library; without it they use the supported library holding the most tracks.

### `refresh_index` (~211 tokens)

Refresh the search index

Rebuild the search index if the library has changed. With more than one library connected, pass `library` (a uuid or path from list_libraries, either the ~/... form or the absolute one) to choose which one; the default is the supported library with the most tracks.

Input parameters:

- `library` (string): Which library to use: either the uuid or the path reported by list_libraries (the reported ~/... form is accepted, as is the absolute path). Omit it to use the supported library holding the most trac…

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/venut-technologies-engine-dj-mcp/engine-dj-mcp#diagnostics

## Score history

- 2026-09-25: 71
- 2026-09-24: 71

## Common questions

### What is the Engine DJ Library Assistant (unofficial) MCP server?

Engine DJ Library Assistant (unofficial) is an MCP server listed in the public MCP registry as io.github.Venut-Technologies/engine-dj-mcp. Ask AI about your Engine DJ library: BPM/key search, audits, cues, opt-in playlist and tag edits. This page covers its npm package (engine-dj-mcp).

### Is the Engine DJ Library Assistant (unofficial) MCP server safe to use?

Engine DJ Library Assistant (unofficial) scores 71 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 25 September 2026. It declares no install or post-install scripts. 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 Engine DJ Library Assistant (unofficial) MCP server expose?

Engine DJ Library Assistant (unofficial) exposes 9 tools: search_tracks, get_tracks, get_playlists, get_playlist_tracks, get_track_performance, and 4 more. Their descriptions and schemas cost roughly 2,967 tokens of context every time the server is loaded.

### Is the Engine DJ Library Assistant (unofficial) MCP server still maintained?

Engine DJ Library Assistant (unofficial) is still listed as active in the MCP registry. We last reached this channel on 25 September 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 Engine DJ Library Assistant (unofficial) MCP server under?

Engine DJ Library Assistant (unofficial) 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

- npm package: https://www.npmjs.com/package/engine-dj-mcp
- Socket report: https://socket.dev/npm/package/engine-dj-mcp
- Repository: https://github.com/Venut-Technologies/engine-dj-mcp
- Changelog RSS feed: https://verifymcp.io/servers/venut-technologies-engine-dj-mcp/engine-dj-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/venut-technologies-engine-dj-mcp/engine-dj-mcp.json
- HTML version of this page: https://verifymcp.io/servers/venut-technologies-engine-dj-mcp/engine-dj-mcp