MnogoReels MCP server

English | Русский

MnogoReels MCP server

MnogoReels MCP server: turn long videos into captioned vertical Shorts/Reels, transcripts and articles from any MCP client. Give your AI assistant a YouTube, VK Video, RuTube, Dzen, Twitch, Yandex Disk, Google Drive or direct video link, and it picks the best moments, reframes them to 9:16, burns in captions and a hook title, and hands back links to the finished clips, using your own MnogoReels account.

One-click install

Client	Hosted server (nothing to install)	Local server (Node.js 22+, npx)
Cursor
VS Code
VS Code Insiders
Kiro
Claude Desktop	not available with an API key (see below)
Smithery

Cursor and Kiro buttons expect MNOGOREELS_API_KEY in your environment; set it and restart the editor, or replace ${env:…} with your key in the config the editor opens. VS Code buttons ask for the key.

GitHub does not render cursor:// and vscode: links as clickable, so copy one into your browser's address bar.

Cursor, hosted:

cursor://anysphere.cursor-deeplink/mcp/install?name=mnogoreels&config=eyJ1cmwiOiJodHRwczovL21jcC5tbm9nby1yZWVscy5ydS9tY3AiLCJoZWFkZXJzIjp7IkF1dGhvcml6YXRpb24iOiJCZWFyZXIgJHtlbnY6TU5PR09SRUVMU19BUElfS0VZfSJ9fQ%3D%3D

Cursor, local:

cursor://anysphere.cursor-deeplink/mcp/install?name=mnogoreels&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsIm1ub2dvcmVlbHMtbWNwQGxhdGVzdCJdLCJlbnYiOnsiTU5PR09SRUVMU19BUElfS0VZIjoiJHtlbnY6TU5PR09SRUVMU19BUElfS0VZfSJ9fQ%3D%3D

VS Code, hosted (asks for the key):

vscode:mcp/install?%7B%22name%22%3A%22mnogoreels%22%2C%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fmcp.mnogo-reels.ru%2Fmcp%22%2C%22headers%22%3A%7B%22Authorization%22%3A%22Bearer%20%24%7Binput%3Amnogoreels_api_key%7D%22%7D%2C%22inputs%22%3A%5B%7B%22type%22%3A%22promptString%22%2C%22id%22%3A%22mnogoreels_api_key%22%2C%22description%22%3A%22MnogoReels%20API%20key%20(mrfrt_usr_...)%22%2C%22password%22%3Atrue%7D%5D%7D

VS Code, local (asks for the key):

vscode:mcp/install?%7B%22name%22%3A%22mnogoreels%22%2C%22type%22%3A%22stdio%22%2C%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22mnogoreels-mcp%40latest%22%5D%2C%22env%22%3A%7B%22MNOGOREELS_API_KEY%22%3A%22%24%7Binput%3Amnogoreels_api_key%7D%22%7D%2C%22inputs%22%3A%5B%7B%22type%22%3A%22promptString%22%2C%22id%22%3A%22mnogoreels_api_key%22%2C%22description%22%3A%22MnogoReels%20API%20key%20(mrfrt_usr_...)%22%2C%22password%22%3Atrue%7D%5D%7D

The Claude Desktop bundle (.mcpb) opens an install dialog that asks for the key and an optional read-only switch. Goose links and every other client are listed under Quick start.

Get your API key

1. Sign in or register at mnogo-reels.ru.
2. Open Developers → API keys and create a key. It starts with mrfrt_usr_.
3. Put it into your client configuration as shown below (MNOGOREELS_API_KEY for the local server, an Authorization: Bearer header for the hosted one).

The key can spend your credits. Use a separate key for each client or machine, never paste it into chats, issues or URLs, and revoke it on the same page when you no longer need it.

Listing tools works without a key, and so do get_account, get_options_guide, check_video_source and quote_clip_job for a new link. Everything that reads your jobs or creates new ones needs the key.

Quick start

Hosted server (recommended)

URL: https://mcp.mnogo-reels.ru/mcp (Streamable HTTP). Send the key in a header:

{
  "mcpServers": {
    "mnogoreels": {
      "type": "http",
      "url": "https://mcp.mnogo-reels.ru/mcp",
      "headers": { "Authorization": "Bearer mrfrt_usr_YOUR_KEY" }
    }
  }
}

• If your client cannot set Authorization, send X-API-Key: mrfrt_usr_YOUR_KEY instead.
• https://mcp.mnogo-reels.ru/mcp/readonly is the same server without any tool that creates jobs or spends credits.
• Never put the key in the URL: the server refuses such requests.

Local server (stdio)

Requires Node.js 22 or newer. The server talks to https://api.mnogo-reels.ru directly from your machine.

{
  "mcpServers": {
    "mnogoreels": {
      "command": "npx",
      "args": ["-y", "mnogoreels-mcp@latest"],
      "env": { "MNOGOREELS_API_KEY": "mrfrt_usr_YOUR_KEY" }
    }
  }
}

"type": "http" is the spelling used by Claude Code, VS Code and Cursor. Cline needs "streamableHttp", Windsurf serverUrl, Gemini CLI httpUrl; the per-client blocks below have the exact form. Ready-made files are in examples/, and docs/clients.md has longer notes per client.

Hosted:

claude mcp add --transport http mnogoreels https://mcp.mnogo-reels.ru/mcp --header "Authorization: Bearer mrfrt_usr_YOUR_KEY"

Local:

claude mcp add mnogoreels --env MNOGOREELS_API_KEY=mrfrt_usr_YOUR_KEY -- npx -y mnogoreels-mcp@latest

Plugin (hosted server plus a make-shorts skill; asks for the key when you enable it):

/plugin marketplace add RealSatanyan/mnogoreels-mcp
/plugin install mnogoreels@mnogoreels

Download mnogoreels-mcp.mcpb and double-click it (or drag it into Settings → Extensions). Claude Desktop asks for the API key and runs the server with its built-in Node.js.

Or add the local server to claude_desktop_config.json (Settings → Developer → Edit Config):

{
  "mcpServers": {
    "mnogoreels": {
      "command": "npx",
      "args": ["-y", "mnogoreels-mcp@latest"],
      "env": { "MNOGOREELS_API_KEY": "mrfrt_usr_YOUR_KEY" }
    }
  }
}

Custom remote connectors with a static API-key header are not available to individual Claude Desktop users, so use the bundle or the local server.

Use the buttons above, or add to ~/.cursor/mcp.json (all projects) or .cursor/mcp.json (one project):

{
  "mcpServers": {
    "mnogoreels": {
      "url": "https://mcp.mnogo-reels.ru/mcp",
      "headers": { "Authorization": "Bearer ${env:MNOGOREELS_API_KEY}" }
    }
  }
}

Local variant: the local server block above, with "MNOGOREELS_API_KEY": "${env:MNOGOREELS_API_KEY}" if you keep the key in your environment.

Use the buttons above, or create .vscode/mcp.json. VS Code asks for the key once and stores it securely:

{
  "inputs": [
    {
      "type": "promptString",
      "id": "mnogoreels_api_key",
      "description": "MnogoReels API key (mrfrt_usr_...)",
      "password": true
    }
  ],
  "servers": {
    "mnogoreels": {
      "type": "http",
      "url": "https://mcp.mnogo-reels.ru/mcp",
      "headers": { "Authorization": "Bearer ${input:mnogoreels_api_key}" }
    }
  }
}

A workspace .mcp.json uses the mcpServers form from Hosted server; do not commit a file that contains your key.

~/.codex/config.toml, hosted (export MNOGOREELS_API_KEY in the shell that starts Codex):

[mcp_servers.mnogoreels]
url = "https://mcp.mnogo-reels.ru/mcp"
bearer_token_env_var = "MNOGOREELS_API_KEY"
tool_timeout_sec = 120

Local:

[mcp_servers.mnogoreels]
command = "npx"
args = ["-y", "mnogoreels-mcp@latest"]
env_vars = ["MNOGOREELS_API_KEY"]
startup_timeout_sec = 60
tool_timeout_sec = 120

Or from the command line:

codex mcp add mnogoreels --env MNOGOREELS_API_KEY=mrfrt_usr_YOUR_KEY -- npx -y mnogoreels-mcp@latest

The default 10-second startup timeout is often too short for the first npx download, hence startup_timeout_sec = 60.

Install the extension (it asks for the key and keeps it in the system keychain):

gemini extensions install https://github.com/RealSatanyan/mnogoreels-mcp

Or add the hosted server to ~/.gemini/settings.json:

{
  "mcpServers": {
    "mnogoreels": {
      "httpUrl": "https://mcp.mnogo-reels.ru/mcp",
      "headers": { "Authorization": "Bearer $MNOGOREELS_API_KEY" }
    }
  }
}

~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "mnogoreels": {
      "serverUrl": "https://mcp.mnogo-reels.ru/mcp",
      "headers": { "Authorization": "Bearer ${env:MNOGOREELS_API_KEY}" }
    }
  }
}

settings.json, hosted:

{
  "context_servers": {
    "mnogoreels": {
      "url": "https://mcp.mnogo-reels.ru/mcp",
      "headers": { "Authorization": "Bearer mrfrt_usr_YOUR_KEY" }
    }
  }
}

Local:

{
  "context_servers": {
    "mnogoreels": {
      "command": "npx",
      "args": ["-y", "mnogoreels-mcp@latest"],
      "env": { "MNOGOREELS_API_KEY": "mrfrt_usr_YOUR_KEY" }
    }
  }
}

Add exactly one of these blocks to cline_mcp_settings.json. Local:

{
  "mcpServers": {
    "mnogoreels": {
      "command": "npx",
      "args": ["-y", "mnogoreels-mcp@latest"],
      "env": { "MNOGOREELS_API_KEY": "mrfrt_usr_YOUR_KEY" },
      "disabled": false,
      "autoApprove": []
    }
  }
}

Hosted:

{
  "mcpServers": {
    "mnogoreels": {
      "type": "streamableHttp",
      "url": "https://mcp.mnogo-reels.ru/mcp",
      "headers": { "Authorization": "Bearer mrfrt_usr_YOUR_KEY" },
      "disabled": false,
      "autoApprove": []
    }
  }
}

Never omit type for the remote entry: Cline treats a remote entry without type as legacy SSE, which this server does not serve. Cline can also set the server up by itself from llms-install.md.

Paste one of these links into your browser's address bar (GitHub does not render goose:// links as clickable). Local, Goose asks for the key:

goose://extension?name=MnogoReels&cmd=npx&arg=-y&arg=mnogoreels-mcp%40latest&env=MNOGOREELS_API_KEY%3DMnogoReels%20API%20key%20(mrfrt_usr_...)&timeout=120&description=Turn%20long%20videos%20into%20captioned%20vertical%20clips%2C%20transcripts%20and%20articles

Hosted, replace mrfrt_usr_YOUR_KEY before opening:

goose://extension?name=MnogoReels&url=https%3A%2F%2Fmcp.mnogo-reels.ru%2Fmcp&header=Authorization%3DBearer%20mrfrt_usr_YOUR_KEY&timeout=120&description=Turn%20long%20videos%20into%20captioned%20vertical%20clips%2C%20transcripts%20and%20articles

Or run goose configure → Add Extension → Command-line Extension with the command npx -y mnogoreels-mcp@latest and the variable MNOGOREELS_API_KEY. A config.yaml example is in examples/goose-config.yaml.

Use the buttons above, or add to ~/.kiro/settings/mcp.json (or .kiro/settings/mcp.json in a project):

{
  "mcpServers": {
    "mnogoreels": {
      "url": "https://mcp.mnogo-reels.ru/mcp",
      "headers": { "Authorization": "Bearer ${MNOGOREELS_API_KEY}" }
    }
  }
}

These clients accept the generic mcpServers JSON: paste the hosted or the local block into their MCP settings (JetBrains: Settings → Tools → AI Assistant → Model Context Protocol; Warp: Settings → AI → MCP servers; Amazon Q: ~/.aws/amazonq/mcp.json; LM Studio: mcp.json). If a client does not support remote servers with headers, use the local block.

Save as .continue/mcpServers/mnogoreels.yaml and add the secret MNOGOREELS_API_KEY in Continue:

name: MnogoReels
version: 1.0.0
schema: v1
mcpServers:
  - name: MnogoReels
    type: streamable-http
    url: https://mcp.mnogo-reels.ru/mcp
    requestOptions:
      headers:
        Authorization: 'Bearer ${{ secrets.MNOGOREELS_API_KEY }}'

Add an MCP Client Tool node to your AI Agent:

• Server Transport: HTTP Streamable
• Endpoint: https://mcp.mnogo-reels.ru/mcp
• Authentication: Header Auth with name Authorization and value Bearer mrfrt_usr_YOUR_KEY

Details: examples/n8n.md.

AI Studio → MCP Hub → «Внешний MCP-сервер» (external MCP server):

• Name: mnogoreels
• URL: https://mcp.mnogo-reels.ru/mcp
• Transport: Streamable HTTP
• Header: Authorization: Bearer mrfrt_usr_YOUR_KEY

Details: examples/yandex-ai-studio.md.

AI Agents → MCP servers → add a server by URL: https://mcp.mnogo-reels.ru/mcp with the header Authorization: Bearer mrfrt_usr_YOUR_KEY.

With langchain-mcp-adapters:

import os

from langchain_mcp_adapters.client import MultiServerMCPClient

client = MultiServerMCPClient(
    {
        "mnogoreels": {
            "transport": "streamable_http",
            "url": "https://mcp.mnogo-reels.ru/mcp",
            "headers": {"Authorization": "Bearer " + os.environ["MNOGOREELS_API_KEY"]},
        }
    }
)
tools = await client.get_tools()

Pass tools to your GigaChat agent. A runnable script is in examples/gigachain.py.

The image runs the local (stdio) server by default:

docker run -i --rm -e MNOGOREELS_API_KEY ghcr.io/realsatanyan/mnogoreels-mcp:latest

As an MCP client entry:

{
  "mcpServers": {
    "mnogoreels": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "-e", "MNOGOREELS_API_KEY", "ghcr.io/realsatanyan/mnogoreels-mcp:latest"],
      "env": { "MNOGOREELS_API_KEY": "mrfrt_usr_YOUR_KEY" }
    }
  }
}

What you can do

Ask your assistant in plain language, for example:

• "Make Shorts from https://www.youtube.com/watch?v=… with Russian captions in the hormozi style. Tell me the price first."
• "How many credits would it cost to clip the first 30 minutes of this podcast? It's 2 hours long."
• "Transcribe this RuTube video and give me SRT subtitles."
• "Write a blog post with chapters from my last clip job."
• "Show my recent clip jobs and the three best clips of each, with their scores and links."

Tools

Every tool declares a title, all four MCP annotations (readOnlyHint, destructiveHint, idempotentHint, openWorldHint) and an output schema. The two credit-spending tools are marked destructiveHint: true, so clients that ask before risky actions (for example Claude and Codex) prompt you on every call.

How to choose a tool

Jobs run in the background

Every create_* tool returns an id right away. The matching get_* tool waits inside the call for up to wait_sec seconds (default 30, max 50) and sends progress notifications meanwhile, so the assistant simply calls it again until the status is completed or failed. Short videos take a few minutes; a full 30-minute range can take tens of minutes. While a clip job is processing, get_clip_job returns only the number of ready clips (set include_partial_clips=true to see them early).

Spending rules

• Price: 1 credit per started minute of the processed range (end_sec − start_sec), minimum 1, charged when the job is created. Examples: 45 s → 1 credit, 10 min → 10, 29 min 30 s → 30. Captions, hooks, B-roll, music and agentic mode do not change the price through the API.
• Free: checks, quotes, transcriptions, articles, YouTube thumbnails, retries of failed jobs and reading results.
• Quote first: quote_clip_job is free and uses the same formula as the backend. The assistant should show you the price and wait for your agreement.
• max_credits is required on create_clip_job and recut_clip_job. The call is refused without charging if the price is higher. An operator can also set a hard cap with MNOGOREELS_MAX_CREDITS_PER_CALL or the X-MnogoReels-Max-Credits-Per-Call header that the model cannot raise.
• 30 minutes per job. MnogoReels processes at most 30 minutes per job, so longer ranges are refused before any charge. Split long videos with start_sec/end_sec (0–1800, 1800–3600, …).
• Duplicate guard: an identical request with the same key within 10 minutes returns the job that was already created instead of charging again (allow_duplicate: true turns this off). The guard lives in one server process; two separate processes do not share it.
• No cancel, no automatic refund. Credits are charged when the job is created and jobs cannot be cancelled. If processing fails, credits are not returned automatically; retry_clip_job re-runs a failed job for free, or contact [email protected] with the job_id.
• Confirmation dialog. Where the client supports MCP form elicitation, the server also asks you to confirm the exact amount before charging:

Prompts and resources

Prompts (slash commands in clients that show them):

Resources:

Prompts and job resources appear only when the tools they use are enabled (for example, /mcp/readonly offers only review_recent_clips). Every capability is also reachable through tools, because many clients never show resources.

Configuration

Environment variables (local server and self-hosting)

Booleans accept 1/true/yes/on and 0/false/no/off. An invalid value stops the server with a message naming the variable (exit code 2). Command line: mnogoreels-mcp [--http] [--help] [--version].

Hosted server: paths and headers

Headers can only narrow what the path allows. Discovery and listing work without a key; a tool call that needs the key and has none gets HTTP 401.

Profiles

Self-hosting the HTTP server

npx -y mnogoreels-mcp@latest --http or docker run -p 8080:8080 -e MNOGOREELS_TRANSPORT=http ghcr.io/realsatanyan/mnogoreels-mcp:latest starts the same server that runs at mcp.mnogo-reels.ru (health check: GET /healthz, server card: GET /.well-known/mcp/server-card.json). Set MNOGOREELS_ALLOWED_HOSTS to your domain. The production setup is described in docs/deploy-coolify.md.

Security

• Untrusted content. Titles, transcripts, articles and other text that comes from videos is wrapped in <untrusted_source_text> tags, and the server instructions tell the model to treat it as data, never as instructions.
• Key hygiene. The key travels only in the Authorization or X-API-Key header (the hosted server rejects keys in URLs), is never logged, and get_account shows only its last 4 characters. Use a dedicated key per client and revoke keys you no longer use. Service keys (mrfrt_svc_…) are rejected.
• Read-only mode. MNOGOREELS_READ_ONLY=true, the /mcp/readonly path or the read-only switch in the Claude Desktop bundle removes every tool that can create jobs or spend credits.
• Only official sources. The server is published only as the npm package mnogoreels-mcp, the image ghcr.io/realsatanyan/mnogoreels-mcp, the hosted endpoint https://mcp.mnogo-reels.ru and this repository. Do not give your key to look-alikes.
• Pinning. mnogoreels-mcp@latest updates automatically. To avoid automatic updates, pin a version, e.g. npx -y [email protected].

Report vulnerabilities privately: see SECURITY.md.

Privacy

The local server sends your tool arguments and key only to api.mnogo-reels.ru. The hosted server receives them at mcp.mnogo-reels.ru and forwards them to the same API; it keeps keys only in memory for the duration of a request and never logs keys, tool arguments or results (only a short hash prefix of the key, to tell users apart). No telemetry is collected. Details: PRIVACY.md, the MnogoReels privacy policy and terms.

Troubleshooting

Tool errors start with Error [<code>]: followed by advice. The most common ones:

Still stuck? Open an issue (remove your key from logs and configs first) or write to [email protected].

Limitations (v1)

• No local files: the video must be reachable by a public link (upload it somewhere public first).
• No credit balance: the API does not expose it; see it on mnogo-reels.ru.
• No publishing or scheduling to social networks.
• No cancelling of jobs.
• Publication packs can be read but not created; failed article images cannot be retried.

Development

Requirements: Node.js 22+. The code is TypeScript (strict), built with tsc, tested with Vitest and Stryker, and written test-first.

npm ci --ignore-scripts
npm run typecheck && npm run lint && npm test
npm run build
npm run test:integration
npm run smoke              # MCP Inspector CLI smoke test
npm run version:check      # manifests in sync with package.json
npm run metadata:check     # README tool tables, MCPB tools, Docker tools.json up to date

See CONTRIBUTING.md for the workflow and docs/release.md for releases. Changes are listed in CHANGELOG.md. Everyone taking part is expected to follow the Code of Conduct.

License

MIT © 2026 MnogoReels