# Reka

> Understand your videos with Reka AI — search, ask questions, and extract insights.

- name: ai.reka/mcp
- version: 0.1.10
- connection class: R1 (autonomous)
- trust: 73/100 flags: no-repository
- quality: 85/100 (good)
- owner: not claimed
- descriptor: https://api.protogrid.dev/v1/servers/ai.reka%2Fmcp
- tools: https://api.protogrid.dev/v1/servers/ai.reka%2Fmcp/tools

**An agent can connect on its own if it already holds `X_REKA_API_KEY`, `X_REKA_API_KEY`.** Remote endpoint behind a static API key or header. The registry never sees the value; the agent fills the placeholder.

## Connection (mcpServers)

```json
{
  "mcpServers": {
    "reka": {
      "type": "http",
      "url": "https://mcp.reka.ai/mcp",
      "headers": {
        "X-Reka-API-Key": "${X_REKA_API_KEY}",
        "Authorization": "${X_REKA_API_KEY}"
      }
    }
  }
}
```

Placeholders to fill: `${X_REKA_API_KEY}`, `${X_REKA_API_KEY}`.

## Trust

- hygiene: 80
- liveness: 100
- freshness: 65
- provenance: 45
- drivers: +dns-namespace +reachable +uptime-100% ~updated-159d-ago -no-repository
- Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed.

## Quality 85/100 (good)

### protocol: 75 (weight 25)

- warn `protocol.modern`: newest supported version is 2025-11-25; 2026-07-28 not supported, older versions are deprecated until 2027-07-28
- n/a `protocol.stateless`: only applies to 2026-07-28 servers
- pass `protocol.transport`: streamable HTTP
- n/a `protocol.list_ttl`: only applies to 2026-07-28 servers

### authorization: n/a (weight 15)

- n/a `auth.prm`, `auth.as_metadata`, `auth.cimd`: no remote uses OAuth
- n/a `auth.secret_in_url`: no templated URL

### tool hygiene: 79 (weight 30)

- pass `tools.descriptions`: every tool has a description
- pass `tools.description_length`: descriptions are concise
- pass `tools.schemas`: every tool has an object input schema
- warn `tools.annotations`: only 13 of 17 tools declare readOnlyHint or destructiveHint
- fail `tools.directory_hints`: no tool declares all four of readOnlyHint, destructiveHint, idempotentHint and openWorldHint; missing: create_group (readOnlyHint, destructiveHint, idempotentHint, openWorldHint); upload_video (readOnlyHint, destructiveHint, idempotentHint, openWorldHint); list_videos (destructiveHint, openWorldHint); …
- pass `tools.token_cost`: about 3,321 tokens to load every tool
- pass `tools.api_dump`: tools are not a one-to-one API dump

### stability: 100 (weight 15)

- pass `stability.changes`: no tool changes in 30 days
- pass `stability.rug_pull`: no tool changed its meaning under the same name

### dependencies: 100 (weight 15)

- pass `deps.known_vulns`: no known advisory in 32 resolved packages
- pass `deps.mcp_sdk_version`: mcp 2.2.0, no known advisory
- pass `deps.resolvable`: reka-mcp@0.1.10 resolved: 32 packages

- tools: 17, about 3,321 tokens to load them all
- tool set hash: 10a1d6d1dce508feca87b737cb953782
- badge: [![protogrid quality](https://protogrid.dev/badge/ai.reka/mcp.svg)](https://protogrid.dev/servers/ai.reka/mcp)
- Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed.

### Tool changes

_No tool definition changes recorded._

## Dependencies

- pypi reka-mcp@0.1.10: resolved, 31 dependencies, MCP SDK mcp 2.2.0

Dependency graphs from deps.dev; advisories from OSV.dev, including the GitHub Advisory Database and the PyPI Advisory Database; all CC BY 4.0.

## Remotes

- https://mcp.reka.ai/mcp (streamable-http, auth api_key ${X_REKA_API_KEY}, reachable true, uptime30d 1)

## Packages

- pypi reka-mcp@0.1.10

## Tools (17)

- `ask_video`: Ask a question about one or more videos with visual analysis. Most effective on focused time ranges — use start/end to specify the segment to analyze.

BEFORE calling this tool, read the reka://docs/guide resource for recommended workflows. In most cases, you should first:
- search_videos to find WHEN something happens, then pass those timestamps here as start/end
- segment_video to detect and locate specific objects
- get_transcript to read what was said

For single-video questions, pass video_id with start/end. For cross-video questions, pass videos — a list of video references with start/end each.

For follow-up questions, pass conversation_id from the previous response. You can add start/end to drill into a specific moment while keeping the conversation context.

Requires qa_only or full pipeline.
- `create_group`: Create a new video group. Groups organize videos into collections. Returns the new group's ID and name.
- `delete_group`: Delete a video group. Videos in the group are not deleted — they are simply removed from the group.
- `delete_video`: Permanently delete a video and all its indexed data (transcript, captions, embeddings, etc.). This cannot be undone.
- `get_captions`: Get AI-generated visual descriptions of what happens on screen. Use this to understand the visual content without watching — each caption describes a short segment with timestamps.

Use start/end to narrow results.

Requires the captions feature (qa_only or full pipeline).
- `get_feature_catalog`: List available video analysis features with their dependencies and descriptions. Use this to understand what features exist and what pipelines to use with index_video.
- `get_scenes`: Get detected scene boundaries with start/end timestamps. Use this to understand the video's structure, then pass scene timestamps as start/end to:
- ask_video for per-scene contextual analysis
- segment_video to detect specific objects per scene (scenes typically fit in segment_video's 15s max range)

Requires transcript indexed with scene detection (on by default; skipped only if index_video was called with scene_detection=False).
- `get_transcript`: Get the spoken words in a video. Use this instead of ask_video when you need to read what was said — it returns the actual text, not a summary.

Use start/end to narrow results for long videos.

Requires the transcript feature to be indexed.
- `get_video`: Get detailed information about a video including upload status, metadata (duration, resolution, fps), and per-feature indexing status. Use this to check if upload or indexing is complete. The 'url' field is a short-lived HTTPS presigned URL (expires within hours) — fetch immediately and do not store; call get_video again for a fresh URL when needed.
- `index_video`: Index a video for search, QA, or full analysis. Processes the video through a pipeline of AI features. Typically takes 3-7 minutes; longer for long videos or the 'full' pipeline. Times out after 10 minutes by default.

Pipelines:
- search_only: transcription + captions + embeddings (enables search_videos)
- qa_only: transcription + captions (enables ask_video)
- full: transcription + captions + embeddings (enables all tools)

Scene detection is enabled by default and produces scene boundaries for get_scenes. Pass scene_detection=False to skip it.

Prerequisites: if using video_id, the video must be in 'uploaded' status. Use get_video to check status before calling this tool.
- `list_groups`: List all video groups. Use list_videos with a group_id to see videos in a specific group.
- `list_videos`: List all videos in your account, or filter to a specific group by passing group_id. Shows upload status and which features have been indexed for each video. Each video's 'url' is a short-lived HTTPS presigned URL (expires within hours) — fetch immediately and do not store; call list_videos or get_video again for a fresh URL when needed.
- `search_videos`: Find WHEN and WHERE something happens across your videos. Returns timestamped results ranked by relevance — use these timestamps as start/end in ask_video for focused analysis.

This is the recommended first step for most questions. Instead of asking ask_video about the entire video, search first to narrow down the relevant moments.

Each result's 'video_url' is a short-lived HTTPS presigned URL (expires within hours) — fetch immediately and do not store; call search_videos or get_video again for a fresh URL when needed.

Requires search_only or full pipeline.
- `segment_video`: Detect objects in a video segment using text prompts. Describe what to look for and get per-frame detections with bounding boxes and confidence scores.

Prompt tips:
- Use broad, visual categories: 'animal', 'vehicle', 'person', 'text on screen'
- Specific labels ('rabbit', 'Toyota') are less reliable — the detector matches visual patterns, not semantic concepts
- Best for confirming whether a category of object appears in a time window, not for precise identification

How to pick a time range:
- Use search_videos to find WHEN something appears, then pass those timestamps here
- Use get_scenes to scan systematically — call segment_video once per scene (scenes typically fit in the 15s window)
- Or pass any range you already know

Maximum range is 15 seconds per call; for longer spans, make multiple calls with consecutive windows.

Does NOT require any feature indexing — works on any uploaded video.
- `summarize_video`: Start here. Get a compact overview of a video: metadata, which features are indexed, a transcript preview, and scene count. Use this to decide which tools to call next — then use segment_video to detect specific objects in time ranges of interest.
- `update_video`: Update a video's display name, title, description, or move it to a different group. At least one field must be provided. To remove a video from its group, pass group_id as null.
- `upload_video`: Upload a video from a URL. Returns a video_id. Local file paths are not accepted; upload files outside the MCP server and pass a reachable video_url. The upload runs asynchronously — poll get_video until status is 'uploaded', then call index_video to enable search and analysis.