# manovagyanik1/clipy-mcp [Health: Active]

**Category:** 🎥 Multimedia Process  
**Repository:** https://github.com/manovagyanik1/clipy-mcp  
**GitHub Stars:** 3  
**Views:** 4  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/manovagyanik1-clipy-mcp

## Description
Read your Clipy screen recordings from any agent: search your library, fetch timestamped transcripts, AI summaries, and key moments with video frames (click markers burned in) as inline images. Read-only, free API key. npx -y @clipy/mcp

## Tools
Capabilities this server exposes over MCP:

- **search_memory** — Search the whole Clipy memory at once** — every screen recording the user made *and* every video they imported — returning the matching moments with timestamps and a URL that opens at that point. Matching is semantic as well as literal, so "login flow" finds a moment where someone said "the authent…
- **search_recordings** — Search your recordings by keyword (title + description).
- **list_recordings** — List your most recent recordings.
- **get_recording** — Metadata for one recording (status, duration, transcript/summary status).
- **get_transcript** — The full timestamped transcript + plaintext.
- **get_summary** — The AI summary: TL;DR, key points, action items.
- **get_browser_diagnostics** — Privacy-redacted visited routes, console warnings/errors, page exceptions, and failed fetch/XHR metadata. The evidence is explicitly labelled page-reported; headers, bodies, cookies, tokens, typed values, and raw query values are never captured.
- **wait_for_artifacts** — Poll until a recording's transcript/summary finish processing.
- **download_recording** — Download the MP4 locally so you can clip it or extract frames yourself (e.g. with ffmpeg).
- **get_key_moments** — Key moments: timestamps, captions, and click coordinates.
- **get_agent_context** — The full agent-context bundle (summary + key moments + transcript + available browser diagnostics) as markdown.
- **record** — Record a web app headlessly** and upload it as a Clipy recording; returns its share + agent-context URLs. Accepts a `type` (recording kind), `viewports` (sweep several screen sizes into one video), `storageState` / `userDataDir`+`profileDirectory` / `initScript` (record behind a login), and timesta…
- **start_recording** — Start a recording session** that keeps recording while you work (drive the page with your own browser tools, run commands, …). Accepts `type`, `storageState` / `userDataDir`+`profileDirectory` / `initScript`, and `exposeCdp` (get a CDP endpoint + in-page `window.__clipyMark`/`window.__clipyChapter`…
- **add_marker** — Drop a narration marker into the active session (live clock, or backdate with `atSeconds`) — markers become the recording's transcript chapters. Can carry evidence in one of two provenances: **clipy-verified** (`assertSelector` / `assertText` / `assertUrl`) where Clipy checks the page itself, or **…
- **add_chapter** — Drop a `=== CHAPTER: <label> ===` boundary into the active session — split a recording into named sections (ideal for before/after demos).
- **stop_recording** — Finish the session: close the browser, upload, return the share + agent-context URLs.
- **abort_recording** — Discard the active session; nothing is uploaded.
- **list_context_documents** — List the user's **context documents** — YouTube videos and local video files they imported with `clipy context import`, so agents can read them. A separate library from their own screen recordings.
- **get_context_document** — One context document's metadata: source, duration, tags, the server's classification (video type, whether visual evidence is needed, planned moments), and which transcript/frames exist. Not the transcript itself.
- **read_context_document** — Read a context document as compiled markdown — header, metadata, then the timestamped transcript with frame captions interleaved. Takes `startMs`/`endMs` so you can walk a two-hour video section by section instead of flooding your context.
- **replace_transcript** — Replace a recording's transcript** with text you author (needs the `ingest` scope). Call `get_transcript` first and pass its `revision`; stale replacements are rejected instead of overwriting a concurrent edit. The summary regenerates automatically. Marked as agent-edited, never passed off as speec…

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "clipy-mcp": {
    "command": "npx",
    "args": ["-y","@clipy/cli@latest"],
    "env": {
      "CLIPY_API_KEY": ""
    }
  }
}
```

**Requires environment variables:** `CLIPY_API_KEY` — the values above are empty placeholders; fill in real credentials before running (see the repository for what each one is for).

## Documentation

## What manovagyanik1/clipy-mcp MCP server does

The manovagyanik1/clipy-mcp MCP server exposes Clipy’s video library to MCP-compatible clients. It supports two main collections: the user’s own screen recordings and imported context videos, such as YouTube videos or local files imported through Clipy. Agents can search across both collections, locate timestamped moments, open matching points through Clipy URLs, and read the surrounding evidence.

For recordings, the server provides metadata, full timestamped transcripts, AI-generated summaries, key moments, browser diagnostics, downloadable MP4 files, and a combined markdown context bundle. Video frames can accompany relevant moments, including click markers rendered into the evidence. Browser diagnostics are privacy-redacted and identify routes, console messages, page exceptions, and failed requests without exposing headers, bodies, cookies, tokens, typed values, or raw query values.

## How it works

Read operations use a Clipy recording’s public ID or its full share URL. A broad search can return hits from either the recordings library or the imported-video library, with a result type indicating which follow-up tools to use. Context documents can be read in time ranges, allowing an agent to process a section of a long video rather than loading the entire transcript at once.

The write path has two modes. The `record` tool launches a headless browser, captures a web application, and uploads the result to Clipy. The session tools provide a longer-lived workflow: start a session, operate the page with other browser tools, add markers or chapters, then stop and upload it. Sessions have an automatic maximum duration, and an active session can instead be discarded with `abort_recording`.

Markers may include page assertions or driver-reported observations. Chapters divide a recording into named sections. Transcript replacement uses a revision value from a prior read, which prevents a stale edit from overwriting a newer change.

## Setup and configuration

The package is started with `npx -y @clipy/mcp` and uses the MCP client’s standard stdio configuration. Before launching it, authenticate with the Clipy CLI using `npx @clipy/cli@latest login`. The login stores credentials in the local Clipy configuration file, which the server can read without requiring the key to be copied into an MCP configuration.

For CI, containers, or a deliberately different credential, set `CLIPY_API_KEY` in the server process environment. The environment variable takes precedence over the local configuration file. Do not place the key in command-line arguments, where local processes may be able to inspect it.

Read tools require the `recordings:read` scope, which is included by default. Recording, session management, and transcript replacement additionally require the `ingest` scope. Headless recording also requires Playwright to be available in the server environment. Capturing the actual Mac screen is outside this MCP server’s scope and is handled by the Clipy CLI instead.

## Tools and capabilities

The manovagyanik1/clipy-mcp MCP server includes tools for:

- Searching all Clipy memory or only recording titles and descriptions.
- Listing recordings and imported context documents.
- Reading recording metadata, transcripts, summaries, key moments, and compiled agent context.
- Inspecting privacy-redacted browser diagnostics.
- Waiting for transcript and summary processing to finish.
- Downloading recordings as MP4 files for local clipping or frame extraction.
- Recording headless browser sessions with viewport sweeps and login-related browser state options.
- Adding timestamped markers, named chapters, and verification evidence.
- Stopping or discarding active recording sessions.
- Reading imported videos in bounded time ranges.
- Replacing a transcript while preserving revision safety and marking the result as agent-edited.

## Limitations and notes

The server does not capture the physical Mac display or a native window; its recording tools use a headless Chromium page. Write operations are unavailable to keys limited to `recordings:read`. Transcript and summary data may require polling before it is ready. Browser diagnostics describe page-reported evidence and intentionally omit sensitive request and input contents. Imported context videos are maintained separately from the user’s screen recordings, although the broad memory search can search both.

_Full upstream README: https://allmcps.com/mcp/manovagyanik1-clipy-mcp/readme_