Your assistant can read every file on your drive and still have no idea what is in them. A folder of 4,000 clips is 4,000 opaque names. Ask which ones show a rocket on the pad at dusk and there is nothing to answer from.

Fast Video Cataloger has already done that work. Cataloging a library extracts scene thumbnails, keywords, transcripts, detected faces and scene classifications into a local database. Version 10.3 opens that database to an AI assistant.

The installer now includes fvc-mcp.exe, a connector built on the Model Context Protocol — the standard assistants like Claude use to reach systems outside themselves. Point one at your catalog and you can ask for footage the way you would ask an assistant editor.

Three ways in, and when to use each

There are three programmable surfaces. They are not competing options; they reach different things.

	Use it when	Runs
MCP server	You want an AI assistant working with your catalog. No code.	Launched by the assistant, talks HTTP to the server
REST API	You are writing your own integration, in any language, possibly on another machine.	In the server
Scripting API	You need what the REST API cannot reach — capturing a frame at an exact time, driving the player, custom UI.	Inside the desktop app

The MCP server is a thin layer over the REST API, so anything it can do you can also do with an HTTP client. It exists so you do not have to write one.

Starting the server

The MCP connector talks to the Fast Video Cataloger server, so that needs to be running. In Fast Video Cataloger, open Start → Server, click Setup, and follow the Share Video Catalog wizard. It installs the server as a Windows service, opens the firewall and connects your application to it.

When it finishes you have a server on an address like http://localhost:8754. Open http://localhost:8754/api/docs in a browser and you get the full REST API, browsable.

If your catalog has user accounts, create an API key for the assistant. A normal login expires after eight hours, which is fine for a browser and useless for something running unattended:

curl -X POST http://localhost:8754/api/v1/apikeys \
     -H "Authorization: Bearer ADMIN_TOKEN" \
     -H "Content-Type: application/json" \
     -d "{\"name\":\"my assistant\",\"role\":\"Viewer\"}"

The key comes back once and is not stored, so save it. Give it Viewer unless you actually want the assistant writing to your catalog — a key cannot be given more privilege than the user who owns it, and you can revoke it at any time.

Connecting an assistant

MCP hosts are configured with a small JSON file naming the program to run. For Claude Desktop or Claude Code:

{
  "mcpServers": {
    "fast-video-cataloger": {
      "command": "C:\\Program Files\\FastVideoCataloger\\fvc-mcp.exe",
      "env": {
        "FVC_SERVER_URL": "http://localhost:8754",
        "FVC_API_KEY": "fvc_your_key_here"
      }
    }
  }
}

Restart the assistant and it has twenty-two tools: searching videos, scenes, transcripts and cast; finding the videos a particular person appears in; listing the keywords your catalog actually uses; reading a video’s scenes, tags and transcript; fetching a scene thumbnail as an image; and — with an Editor key — tagging, taking keywords off again, building bins, and indexing.

That block is the Claude form. Other hosts register the server their own way — Gemini CLI, for instance, takes it on the command line with a bearer header rather than in a config file — but they run the same fvc-mcp.exe. The connector was verified against Gemini CLI 0.57.0 and driven independently by GPT-5, and the two agreed with each other: same videos, same timecodes, same thumbnail contents, including the vision calls and a tag/untag write round trip. That is what you want from a standard protocol, and it is the reason this post talks about “an assistant” rather than a particular one.

If you would rather watch it than read it, there is a three-minute walkthrough of the whole thing — asking for footage, the assistant judging shots from the thumbnails, and the three steps to connect one yourself:

Here is an actual session against a catalog of NASA interview footage. The ask was:

I am cutting a trailer. Find the clips in my video catalog where someone actually says the word “launch”. For each one, look at a representative scene image and tell me whether the shot looks usable for a trailer. Then gather the usable ones into a new bin called “Trailer – launch”.

Nobody told it which tools to use or in what order. It called search_transcripts once, which came back with five spoken hits across three videos, each with its timecode. Then get_video and get_video_scenes for those three, seven get_scene_image calls to look at the frames, and finally create_bin and three add_video_to_bin calls. Twenty-one steps, about eighty seconds.

What it reported back:

Video 2 — Artemis Interviews with NASA Astronaut Jeanette Epps (19:25)

04:31 — “…the program that would take us back to the moon along with the Gateway and the Space Launch System”

11:02 — “…we would launch to the Gateway and from Gateway land on the surface of the moon”

[…]

Video 2 — usable. Nearest frame is 4:20 before the first hit, but this is a locked-off studio setup so it’s representative: clean medium shot of Epps in the blue NASA flight suit, evenly lit, sharp, framed against an EVA mural and the Artemis logo. Reads as a hero talking-head. The only other thumbnail (19:19) is the “EXPLORE / Humans in Space” end card — that’s a title-card asset, not a shot, so avoid the tail of the file.

Video 13 — usable, and the strongest visual. Frames bracketing the 1:37 line at 0:20 and 2:19 show the identical setup, so the shot is almost certainly continuous through the line: Bowen floating in an ISS module, hardware and cabling filling the frame. Genuine orbital imagery, which is what a trailer wants. Two things to weigh — it’s a downlink feed so expect softness and compression against your other sources, and the background is visually busy for any title overlay.

Created “Trailer – launch” (id 3) and added all three videos.

If you want tighter picks, I’d suggest re-indexing videos 2 and 3 at a denser scene interval; right now the thumbnails are too sparse to confirm framing at the exact moments you’d cut on.

That is the part that changes the character of it. get_scene_image hands over the actual thumbnail, so the assistant is looking at the frame rather than guessing from a filename — which is how it can tell a title card from a shot, notice that one file’s thumbnails bracket the line closely enough to infer the shot holds, and end by telling you your scene interval is too sparse for the job you asked of it.

The same thing without MCP

MCP is a convenience, not a lock-in. Everything above is the REST API underneath, and it works from any language:

# Find the moments where something is said. This returns the ids of the matching
# transcript lines; read one to get its text, its video and its timecode.
curl "http://localhost:8754/api/v1/subtitles/search?search=launch"
curl "http://localhost:8754/api/v1/subtitles/133"

# Find individual scenes by keyword, with their timecodes
curl "http://localhost:8754/api/v1/thumbnails/search?keywords=launch&limit=20"

# Tag a video
curl -X PUT http://localhost:8754/api/v1/videos/12/tags \
     -H "Content-Type: application/json" \
     -d "{\"tags\":\"trailer,apollo\"}"

Responses are JSON in a {"success": true, "data": ...} envelope. The OpenAPI specification at /swagger/v1/swagger.json describes every endpoint, which is usually the fastest way to point a code generator — or an assistant — at the API.

Version 10.3 also adds an endpoint to index a video that is already in the catalog. Combined with the list of entries that still need indexing, a script can work through a backlog on its own:

curl http://localhost:8754/api/v1/videos/pending-indexing
curl -X POST http://localhost:8754/api/v1/videos/12/index

Indexing applies whatever the server is configured for, so this is also how transcription and the AI features get run over new material.

When you need more than the API

Some things are not in the REST API and deliberately so: capturing a single frame at an exact time, driving the video player, building a custom window. Those live in the C# scripting API, which runs inside the desktop application and reaches the parts a network API does not.

There is also fvc.exe, a small command line tool that passes a line of text to a running copy of the program and prints back whatever your script returns — a one-line bridge for wiring the application into anything else you already run locally.

Where your video goes

Nowhere. The assistant reaches your catalog through a local address on your own machine. The catalog, the thumbnails and the video files stay where they are. Nothing is uploaded to us, and nothing needs to be for any of this to work.

Two things worth being deliberate about. An API key is a credential — give it the smallest role that does the job, and revoke it when you are done. And if your catalog has no user accounts configured, the server does not require authentication at all, which is fine on your own machine and not fine on a network you share.

What it will not do yet

It cannot play a video, capture a frame at an exact time, or drive the player. Those stay with the scripting API inside the desktop application.
It can create bins and add videos, but not delete a bin or take a video out of one — that is done in Fast Video Cataloger.
No endpoint to trigger transcription or AI tagging on their own — they run as part of indexing a video, not as separate operations.
Search over the API is narrower than the desktop search window: keywords, people, title, rating and genre, but not the full set of filters.
Transcript search works a line at a time. Several words are treated as “all of these, in the same line”, and quoting a phrase matches it in order — but a sentence split across two subtitle lines is not found as one hit.
One video is indexed at a time. Requests queue rather than run in parallel.
The connector speaks MCP over stdio, which every current MCP client supports — but hosts differ in how they let you hand over credentials. Some take a static API key from the server’s environment, as above; others only offer OAuth, or no authentication at all. Whether a particular assistant can connect straight to your catalog is decided by its host, not by the connector.

Fast Video Cataloger 10.3 is available from the download page. The setup guide is under Connect an AI Assistant in the server documentation.

Let an AI assistant search your video library