# Yueying – Let AI watch videos (pypi · yueying)

Local videos or YouTube/Bilibili URLs -> timestamped transcript, keyframes, contact sheets. Offline.

- Trust score: 71/100 (medium)
- Change this week: +17
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-20

## Components

- pypi · `yueying`: 71/100 (this document), [markdown](https://verifymcp.io/servers/vsh5dvsch7-png-yueying/yueying.md), [page](https://verifymcp.io/servers/vsh5dvsch7-png-yueying/yueying)

## Channel facts

- Registry: `pypi`
- Package: `yueying`
- Version: `0.2.1`
- 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-20.

- **Supply Chain Security**: 97/100
  - No malware found by supply-chain analysis.
  - Known CVEs were checked across the 48 of 53 dependencies we could resolve, so this covers what we could see, not the whole tree.
  - Runs setuptools.build_meta at install time, a recognised native-build step with no shell scripting around it.
  - Dependency health was assessed across the 48 of 53 dependencies we could resolve, so this covers what we could see, not the whole tree.
- **Provenance & Transparency**: 48/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 7 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 63/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 1670 tokens (~278/item across 6 items; 6 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 95/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 86% 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 6 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 7 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).

## Install

### How do I install the Yueying – Let AI watch videos MCP server?

Yueying – Let AI watch videos runs locally as a PyPI package, launched with uvx yueying. 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 vsh5dvsch7-png-yueying -- uvx yueying
```

### Cursor

```json
{
  "mcpServers": {
    "vsh5dvsch7-png-yueying": {
      "command": "uvx",
      "args": [
        "yueying"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "vsh5dvsch7-png-yueying": {
      "command": "uvx",
      "args": [
        "yueying"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add vsh5dvsch7-png-yueying -- uvx yueying
```

### opencode

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

### OpenClaw

```bash
openclaw mcp add vsh5dvsch7-png-yueying --command uvx --arg yueying
```

### Hermes

```yaml
mcp_servers:
  vsh5dvsch7-png-yueying:
    command: "uvx"
    args: ["yueying"]
```

### Netclaw

```json
{
  "McpServers": {
    "vsh5dvsch7-png-yueying": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "yueying"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add vsh5dvsch7-png-yueying -t stdio -c uvx -a yueying
```

### Other

```json
{
  "mcpServers": {
    "vsh5dvsch7-png-yueying": {
      "command": "uvx",
      "args": [
        "yueying"
      ]
    }
  }
}
```

## 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-20 (score 71, −1)

- [security regression] Known CVEs: pass → partial
- [functional] Dependency health: 0.99 → partial

### 2026-09-19 (score 72, +16)

- [security improvement] Malware scan: unverified → pass

### 2026-09-17 (score 56, −14)

- [security regression] Malware scan: pass → unverified

### 2026-09-14 (score 70, +16)

- [security improvement] Malware scan: unverified → pass

### 2026-09-13 (score 54, 0)

- [functional improvement] Stability: unverified → 0.03
- [functional] Package version: 0.2.0 → 0.2.1

### 2026-09-12 (score 54)

First indexed and scored.

## MCP tools (6)

### `watch_video` (~588 tokens)

Turn a video into a timestamped transcript plus a keyframe overview so you can summarize it, answer questions about it, extract steps, commands or code, or write notes. `video` is an absolute path to a local video/audio file or a YouTube / Bilibili / Douyin / Xiaohongshu / TikTok / Vimeo URL. Fully offline: platform subtitles are used when they exist, otherwise local Whisper speech recognition (GPU when available, CPU otherwise); no API key. Results are cached per video, so calling again with the same video is instant. Typical time: 5–60 s for short subtitled videos, a few minutes for long videos without subtitles; the very first speech recognition downloads a model once (~480 MB on CPU, ~1.6 GB on GPU). If the reply starts with RUNNING, call watch_video again with the same `video` — it resumes waiting for the same job; do not change options and do not start other videos meanwhile. The reply is an English overview: metadata, chapters, the list of contact sheets (see them with get_frames), file paths, and the transcript with [mm:ss] timestamps (truncated at max_chars with a start time for get_transcript). Cite timestamps like (03:15). Not for live streams or images.

Input parameters:

- `cookies_from_browser`: Reuse a browser login for HD or member-only Bilibili / sign-in-gated YouTube. Close Chrome first on Windows
- `frame_interval_seconds`: Approximate seconds between keyframes; None = automatic by duration (2–20 s). Use 2 for code/slide-heavy screencasts
- `language` (string): Spoken language; auto detects it. Set it when you know it for better accuracy
- `max_chars` (integer): Maximum characters of transcript included in the reply
- `mode` (string): full = transcript + keyframes (default); transcript = no keyframes; frames = no speech recognition (platform subtitles still used)
- `model` (string): Whisper model used only when the video has no subtitles. auto = large-v3-turbo on an NVIDIA GPU, small on CPU
- `output_dir`: Absolute folder for the results; default $YUEYING_OUT_DIR/<name>-<id>
- `refresh` (boolean): Discard cached results (and any running job) for this video and process it again
- `video` (string, required): Absolute path to a local video/audio file, or a video page URL (YouTube, Bilibili, Douyin, Xiaohongshu, TikTok, Vimeo, X and other yt-dlp sites)
- `wait_seconds` (integer): How long this call may block before answering RUNNING. Keep 45 in Claude Desktop/Cursor (60 s client timeout); Claude Code/Cline may use up to 1500

### `get_transcript` (~189 tokens)

Read part of an already-watched video's transcript with [mm:ss] timestamps. Use when the watch_video overview was truncated, when the user asks about a specific time range, or to export subtitles (format='srt'). Returns at most max_chars; when truncated the last line gives next_start so you can continue from there. Paragraph format is the cheapest.

Input parameters:

- `end`: End time (same formats); None = to the end
- `format` (string): paragraphs = compact [mm:ss] text (fewest tokens); segments = one line per subtitle cue with start-end; srt = subtitle blocks
- `max_chars` (integer)
- `start` (string): Start time: seconds, mm:ss or h:mm:ss
- `video` (string, required): video_id from watch_video/list_videos, the results folder, or the same path/URL given to watch_video

### `search_transcript` (~157 tokens)

Find where something is said in an already-watched video. Each hit shows the time, the surrounding sentences, and the nearest keyframe number and contact-sheet number so you can follow up with get_frame_at or get_transcript. Use this instead of paging the whole transcript when the user asks 'when does he mention X' or 'find the part about Y'.

Input parameters:

- `context_seconds` (number): Seconds of surrounding text to include around each hit
- `limit` (integer)
- `query` (string, required): Words to look for; separate alternatives with spaces (any term matches, more terms rank higher). Case-insensitive
- `video` (string, required): video_id, results folder, or the path/URL given to watch_video

### `get_frames` (~257 tokens)

See what is on screen in an already-watched video. Returns contact-sheet images (3x3 keyframes in time order, every tile labelled '#number mm:ss' bottom-left) or individual keyframes. Read the contact sheets first to get the visual storyline, then request single frames only when you need to read code, slides or UI text. At most 3 images per call (default 2), downscaled to max_width; page with start/count. Every image is preceded by its absolute file path so hosts that can read files may open the full-size original instead.

Input parameters:

- `count` (integer): Images per call; keep 2 or fewer in Claude Desktop
- `kind` (string): grids = 3x3 contact sheets, 9 keyframes per image (start here); frames = individual full-size keyframes
- `max_width` (integer): Downscale width in pixels; 1280 is about 150 KB per contact sheet
- `start` (integer): 1-based number of the first image: contact-sheet number for grids, keyframe number (as printed on the tiles) for frames
- `video` (string, required): video_id, results folder, or the path/URL given to watch_video

### `get_frame_at` (~145 tokens)

Look closely at one moment of an already-watched video, e.g. to read code, a slide, a chart or a UI. For local files that still exist the exact frame at that time is extracted from the video; otherwise the nearest cached keyframe is returned and the caption says so. Also returns the transcript paragraphs spoken around that time. Returns one image (~100 KB at 960 px).

Input parameters:

- `max_width` (integer)
- `time` (string, required): Timestamp: seconds, mm:ss or h:mm:ss, e.g. '03:15'
- `video` (string, required): video_id, results folder, or the path/URL given to watch_video

### `list_videos` (~90 tokens)

List videos already processed by yueying on this machine (newest first) and jobs currently running, with video_id, title, duration, text source, date, folder and size. Use when the user refers to a video watched earlier, to get a video_id for the other tools, or to see how much disk space results use. Instant and read-only.

Input parameters:

- `limit` (integer)

## Diagnostics

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

## Score history

- 2026-09-20: 71
- 2026-09-19: 72
- 2026-09-18: 56
- 2026-09-17: 56
- 2026-09-16: 70
- 2026-09-15: 70
- 2026-09-14: 70
- 2026-09-13: 54
- 2026-09-12: 54

## Common questions

### What is the Yueying – Let AI watch videos MCP server?

Yueying – Let AI watch videos is an MCP server listed in the public MCP registry as io.github.vsh5dvsch7-png/yueying. Local videos or YouTube/Bilibili URLs -> timestamped transcript, keyframes, contact sheets. Offline. This page covers its PyPI package (yueying).

### Is the Yueying – Let AI watch videos MCP server safe to use?

Yueying – Let AI watch videos scores 71 out of 100 on VerifyMCP. 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 Yueying – Let AI watch videos MCP server expose?

Yueying – Let AI watch videos exposes 6 tools: watch_video, get_transcript, search_transcript, get_frames, get_frame_at, list_videos. Their descriptions and schemas cost roughly 1,426 tokens of context every time the server is loaded.

### Is the Yueying – Let AI watch videos MCP server still maintained?

Yueying – Let AI watch videos is still listed as active in the MCP registry. We last reached this channel on 20 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 Yueying – Let AI watch videos MCP server under?

Yueying – Let AI watch videos 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/yueying/
- Socket report: https://socket.dev/pypi/package/yueying
- Repository: https://github.com/vsh5dvsch7-png/yueying
- Changelog RSS feed: https://verifymcp.io/servers/vsh5dvsch7-png-yueying/yueying.xml
- Changelog JSON feed: https://verifymcp.io/servers/vsh5dvsch7-png-yueying/yueying.json
- HTML version of this page: https://verifymcp.io/servers/vsh5dvsch7-png-yueying/yueying