# io.github.most-ai-com/mostai-mcp (pypi · mostai-mcp)

Generate images, video, music, speech and text with 60+ models through your MostAI account.

- Trust score: 50/100 (low)
- Change this week: +4
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-22

## Components

- pypi · `mostai-mcp`: 50/100 (this document), [markdown](https://verifymcp.io/servers/most-ai-com-mostai-mcp/mostai-mcp.md), [page](https://verifymcp.io/servers/most-ai-com-mostai-mcp/mostai-mcp)

## Channel facts

- Registry: `pypi`
- Package: `mostai-mcp`
- Version: `0.7.2`
- 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-22.

- **Supply Chain Security**: 50/100
  - Malware scan not yet available for this package.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs hatchling.build at install time, a recognised native-build step with no shell scripting around it.
  - 3 of 44 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 6/100
  - Repository check failed: the declared repository URL returned HTTP 404.
  - Provenance check failed: no build-provenance attestation is published.
  - License check failed: no license is declared.
  - Actively maintained (last published 16 days ago).
  - Security-disclosure policy not yet verified: we couldn't inspect the source repository.
- **Schema Quality & AI Usability**: 62/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 7877 tokens (~328/item across 24 items; 24 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 57/100
  - Stability observed for 17 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 71/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 0% of tool parameters carry a description.
  - Structured output schemas are declared (13% of tools); any adoption earns full credit.
- **Tool Safety**: 75/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 0 of 2 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "delete_media" implies "delete" and declares no destructiveHint at all, which the MCP spec reads as destructive by default.
  - An AI judge read all 24 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the io.github.most-ai-com/mostai-mcp server?

io.github.most-ai-com/mostai-mcp runs locally as a PyPI package, launched with uvx mostai-mcp. 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 most-ai-com-mostai-mcp -- uvx mostai-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "most-ai-com-mostai-mcp": {
      "command": "uvx",
      "args": [
        "mostai-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "most-ai-com-mostai-mcp": {
      "command": "uvx",
      "args": [
        "mostai-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add most-ai-com-mostai-mcp -- uvx mostai-mcp
```

### opencode

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

### OpenClaw

```bash
openclaw mcp add most-ai-com-mostai-mcp --command uvx --arg mostai-mcp
```

### Hermes

```yaml
mcp_servers:
  most-ai-com-mostai-mcp:
    command: "uvx"
    args: ["mostai-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "most-ai-com-mostai-mcp": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "mostai-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add most-ai-com-mostai-mcp -t stdio -c uvx -a mostai-mcp
```

### Other

```json
{
  "mcpServers": {
    "most-ai-com-mostai-mcp": {
      "command": "uvx",
      "args": [
        "mostai-mcp"
      ]
    }
  }
}
```

## 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-22 (score 50, +1)

No change was recorded against any check on this day. Stability & Change Management went from 53 to 57. That category is still filling its 30-day observation window: 16 days of observed history at the previous scan, 17 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-20 (score 49, +1)

No change was recorded against any check on this day. Stability & Change Management went from 47 to 50. That category is still filling its 30-day observation window: 14 days of observed history at the previous scan, 15 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-18 (score 48, +1)

No change was recorded against any check on this day. Stability & Change Management went from 40 to 43. That category is still filling its 30-day observation window: 12 days of observed history at the previous scan, 13 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-16 (score 47, +1)

No change was recorded against any check on this day. Stability & Change Management went from 33 to 37. That category is still filling its 30-day observation window: 10 days of observed history at the previous scan, 11 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-14 (score 46, +1)

No change was recorded against any check on this day. Stability & Change Management went from 27 to 30. That category is still filling its 30-day observation window: 8 days of observed history at the previous scan, 9 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-09-13 (score 45, −15)

- [security regression] Malware scan: pass → unverified

### 2026-09-12 (score 60, +18)

- [security improvement] Malware scan: unverified → pass
- [functional improvement] Stability: unverified → 0.23

### 2026-09-10 (score 42, −15)

- [security regression] Malware scan: pass → unverified

## MCP tools (24)

### `list_models` (~373 tokens)

List MostAI models, LIVE from the API. Prices are in ₽ per generation.

\`type`: 'image', 'video', 'audio' or 'text' (omit for everything). Sorted cheapest
first by default; text models sort by `price_rub_per_1k_tokens.output` instead (free
models first), since they are billed in ₽ per token, not in ₽ per generation.

Shortlist by capability from this list, then call describe_model(id) for the exact
parameters that model accepts. Each row carries:
\- `free_left` — remaining free generations. -1 = unlimited; null = no free tier. The
  key is always present, so test for null, not for absence.
\- `capabilities` — what the model can do, e.g. 'image:edit', 'video:first_last_frame',
  'video:audio_rus', 'low_moderation'. This is the field to filter on.
\- `inputs` — which attachment SLOTS exist and their limits ("image≤14", "image=1
  (required), audio=1 (required)"). It says nothing about what each slot is FOR;
  describe_model spells that out.
\- `no_prompt` — True = an "AI app" driven by attachments/parameters, called through
  generate_media.
\- `badge`, `price_per_sec_rub` (added per second of video) and `price_from` (True =
  the listed price is the cheapest tier; the real charge depends on quality/duration —
  use estimate_price for that).

Retired models are hidden, matching the website; pass include_deprecated=True to see
them.

Input parameters:

- `include_deprecated` (boolean)
- `sort_by_price` (boolean)
- `type`

Output parameters:

- `result` (array)

### `describe_model` (~278 tokens)

Everything needed to call one model correctly on the first try.

Returns the normalized spec: `parameters` ({name: {type, options, default}} — the
allowed values, e.g. duration 5/10/15, quality 720p/1080p), `inputs` (attachment
slots with max counts / durations and whether they are required), `no_prompt`,
\`named_inputs` (uuid-valued slots such as faceswap's swap_image / input_image — pass
them to generate_media as `named_images={slot: file}`), `capabilities`, `badge`,
\`disclaimer` (plain text), price (`price_rub` + `price_per_sec_rub`), `free_left` and
an `example_call` you can copy. Two fields appear only where they exist: `presets`
(dance templates — only on kwaivgi/kling-v2.6-motion-control) and `voices` (only on the
three TTS models: elevenlabs/v3, elevenlabs/text-to-dialogue-v3,
google/gemini-3.1-flash-tts).

Call this before generating with an unfamiliar model — the generic tool defaults are
not valid for every model, and a wrong parameter is refused before it costs anything.

Input parameters:

- `model_id` (string, required)

### `get_balance` (~106 tokens)

Current MostAI balance in ₽, plus the free generations available right now.

\`free_generations` maps model id -> free runs remaining TODAY (-1 = unlimited; the
quota resets daily at `free_reset_at`, UTC). Those cost 0₽: the generate_* tools use
them automatically when quota remains and you did not pin a paid quality/duration.
The map is cached and may be up to 60 s stale — list_free_generations() reads it live.

### `spending_status` (~228 tokens)

Show balance and the configured spending guards (low-balance threshold + price caps).

Configure via env: MOSTAI_MIN_BALANCE (low-balance alert, default 50),
MOSTAI_WARN_PRICE (mark a generation 'expensive', default 50),
MOSTAI_MAX_PRICE (hard cap — refuse generations above it; unset = no cap),
MOSTAI_DEDUPE (0 = duplicate guard off), MOSTAI_DEDUPE_WINDOW_S (how long an
identical generate_* repeat returns the earlier result; unset = 600 s image/audio,
1200 s video; 0 = never reuse a finished result, a running one is still never started
twice) and MOSTAI_WARN_CHAT_RUB (ask_second_opinion/chat: 0 = every paid text model
needs confirm=True, N = ask only when the estimated cost is >= N ₽).

A `max_price` passed to a single generate_* call REPLACES the MOSTAI_MAX_PRICE cap for
that one call — it is a per-call cap, not an extra limit on top of the configured one.

### `whoami` (~46 tokens)

Account profile: email, message credits and permissions.

\`message_credits` is a separate currency from the ₽ balance: it pays for `chat`
messages only, media generation spends ₽.

### `topup` (~143 tokens)

Get the link to add funds to the MostAI balance. The USER pays on the MostAI page —
this server cannot take, hold, confirm or route a payment (no such capability, by design);
it only hands over the link. On that page the user picks their country and payment method
(card, SBP, etc. — the site shows what fits their country) and any current bonus is shown
there. Relay `pay_url` to the user and tell them to open it; nothing is charged here.
\`amount_rub` is optional and only used to phrase the message — the amount is chosen on the page.

Input parameters:

- `amount_rub`

### `chat` (~259 tokens)

Generate text with a MostAI text model and return the full reply.

\`chatgpt-free` (default) costs nothing and is unlimited. Every other text model bills ₽
PER TOKEN — `price_in_per_token` / `price_out_per_token` in describe_model (the
catalogue's `credits_per_message` is a legacy number, not what MostAI charges) — bonuses
first, then the ₽ balance, booked after the reply. Their `price_rub: 0` does NOT mean
free. This tool has no confirmation gate: for a paid model prefer ask_second_opinion,
which quotes the price and asks first.

\`session` continues a MostAI-side conversation: the files attached there come back
automatically, but earlier TURNS are not replayed by the backend — use
ask_second_opinion(session=...) for a follow-up that remembers the previous answer.

No text model can see a picture (attachments_limit=0 on all of them). To have a model
READ a document, spreadsheet, picture (OCR) or recording, use
ask_second_opinion(files=[...]).

Input parameters:

- `model` (string)
- `prompt` (string, required)
- `session`
- `system`

Output parameters:

- `result` (string)

### `ask_second_opinion` (~764 tokens)

Get an independent SECOND OPINION from a different AI model — optionally on files it
reads. Offer this proactively whenever an outside check would help: a plan you are about
to commit to, a risky or contested decision, a calculation, generated code before it
ships, a document worth a second reader. The default `chatgpt-free` costs 0 ₽ and is
unlimited, so a sanity check is always safe. Any other text model bills ₽ PER TOKEN
(see `cost` in the reply, `price_in_per_token`/`price_out_per_token` in
describe_model) — bonuses first, then the ₽ balance, after the reply. A paid model returns
\`status: "needs_confirmation"` with the price and an estimate BEFORE anything is uploaded
or sent; relay it to the user and re-call with confirm=True only after they agree (see
MOSTAI_WARN_CHAT_RUB). Never spend on a paid model without that.

\`files`: one local path or a list (max 10, 50 MB each, no URLs). Documents
(pdf/docx/pptx/txt/md/rtf/epub/…), spreadsheets (xlsx/csv/…), pictures (jpg/png/gif/webp/
heic/svg — OCR'd AS TEXT: the consultant reads what was extracted, it does NOT see the
picture) and audio/video (mp3/mp4/wav/m4a/webm — the audio track is transcribed; .mov is
refused). Parsing is asynchronous (seconds to a few minutes); this call waits up to
\`wait_timeout` seconds (default 180, max 300). It NEVER sends while a file is still
parsing — you get `status: "files_pending"` (nothing sent, nothing spent) and re-call with
the same `session` (omit `files`) a little later. Parsed files stay attached to the
session and are re-injected into EVERY later message there — free on chatgpt-free, billed
as prompt tokens each time on a paid model.

\`on_parse_error`: "auto" (default) — on a free model, answer using the files that parsed
and warn about the failed ones; on a paid model, or when no file parsed at all, return
\`status: "parse_failed"` without sending. "abort" always returns parse_failed;
"continue" always sends with what parsed.

\`session`: pass the value a previous call return…

Input parameters:

- `confirm` (boolean)
- `files`
- `model` (string)
- `on_parse_error` (string)
- `question` (string, required)
- `session`
- `system`
- `wait_timeout` (number)

### `estimate_price` (~250 tokens)

Price a media generation in ₽ WITHOUT running or paying for it.

Pass the same `duration` / `quality` / `parameters` you intend to generate with —
price depends on them (a 30s 1080p clip is not the catalogue's "from" price).
\`duration` / `quality` given here override the same keys in `parameters`, and both
take exactly the strings/ints describe_model lists (e.g. '1080p', 10). Invalid values
are refused here, listing what the model allows; model ids come from
list_models(type='video').

Returns `price_rub` (per generation), `price_per_sec_rub` (added per second, video)
and `free_left`: -1 = unlimited free runs / a positive number = that many free runs
left / 0 = the free quota is used up / null = this model has no free tier. With free
quota the generation can cost 0₽ instead of the quoted price.

Input parameters:

- `aspect_ratio`
- `duration`
- `model` (string, required)
- `parameters`
- `prompt` (string)
- `quality`

### `generate_image` (~768 tokens)

Generate an image from a prompt. Costs ₽ (single digits to ~10₽ for the popular
models) — or 0₽ when free quota is available, which happens automatically.

Default `google/nano-banana-2` follows instructions well, edits, and has free
generations. See list_models(type='image') for the rest and describe_model(model) for
that model's valid `quality`; leave it None to take the model's own default. `images` =
reference pictures (a bare https URL/local path, or a list of them) for image-to-image
on edit-capable models — edit_image is the simpler shape for that. A `url` from an
earlier generate_*/media_status/list_gallery result works here too — no download needed.

\`aspect_ratio` is checked against the catalogue when the model lists `aspect_ratio`
options (describe_model). Some models honour it WITHOUT declaring it in the
catalogue — e.g. google/nano-banana-2, google/nano-banana-pro, openai/image-2, and
video models that offer it in the studio UI: a common value ('1:1', '16:9', '9:16',
'4:3', '3:4', …) still works there, it just cannot be validated up front, and an
unrecognised value on one of THESE models is silently dropped by the backend rather
than rejected — check the actual output if you are not sure it took effect.

Money: an invalid parameter is refused before anything is charged. A generation at or
above MOSTAI_WARN_PRICE (default 50₽) returns `needs_confirmation` and charges
nothing — relay the price to the user and only then re-call with confirm=True.
\`max_price` is a per-call cap that REPLACES the MOSTAI_MAX_PRICE hard cap for this
call (omit it to keep the configured cap).

\`free_mode`: None = auto (free when quota remains and you did not pin quality), True =
force free (the backend then locks quality/duration to the cheapest option), False =
always pay. `save_path` also downloads the result — pass an absolute path: a relative
one resolves against the server's working directory, not yours. `wait=False` returns
{public_id, status:'progress'} at once — poll me…

Input parameters:

- `aspect_ratio`
- `confirm` (boolean)
- `free_mode`
- `images`
- `max_price`
- `model` (string)
- `new_variant` (boolean)
- `parameters`
- `prompt` (string, required)
- `quality`
- `save_path`
- `wait` (boolean)

### `edit_image` (~291 tokens)

Image-to-image: transform an existing picture according to `prompt`.

\`source` = the reference image as an https URL or a local file path (or a list of
them to combine several). When `source` is a list, every picture is a reference of
equal standing — say in `prompt` which one is the photo to redraw and which are style
references. Use an edit-capable model (`capabilities` contains 'image:edit' — see
list_models / describe_model); the default google/nano-banana-2 takes up to 14
references and has free quota.

For removing a background, upscaling, enhancing or swapping a face, do NOT prompt an
edit model — call the dedicated app through generate_media (see its docstring): it is
cheaper and far more reliable. Money, `free_mode`, `aspect_ratio` (including on
models that honour it without declaring it in the catalogue — see generate_image)
and the duplicate guard (`new_variant`) behave exactly as in generate_image.

Input parameters:

- `aspect_ratio`
- `confirm` (boolean)
- `free_mode`
- `max_price`
- `model` (string)
- `new_variant` (boolean)
- `prompt` (string, required)
- `quality`
- `save_path`
- `source` (required)
- `wait` (boolean)

### `generate_video` (~739 tokens)

Generate a video from a prompt (and optional pictures). Costs ₽ — video is the
expensive family, tens to hundreds per clip, so check estimate_price first when the
model is unfamiliar.

Default `xai/grok-imagine-video` is the budget option with Russian voice-over and
free quota. See list_models(type='video'); describe_model(model) lists the valid
\`duration` (in seconds) / `quality` / `mode` for that model. Leave a parameter None and
the model's own default applies — nothing is sent that you did not ask for.
\`xai/grok-imagine-video-1.5` and `minimax/hailuo-2.3-fast` are image-to-video ONLY — a
call with no `images` is refused before anything is uploaded or charged.

\`mode` is MODEL-SPECIFIC. Only models whose `mode` options include
'reference'/'frames' place pictures as first/last frame: bytedance/seedance-2.5-turbo,
bytedance/seedance-2-fast, bytedance/seedance-2-mini, wan/3-0-video,
minimax/minimax-h3, google/veo-3.1-fast, google/veo-3.1-fast-relax as of the
2026-09-03 snapshot. There 'reference' = each picture is a style/subject reference and
'frames' = the first picture is the first frame, an optional second the last (this tool
keeps whatever `mode` you pass, including its default 'reference' on those five models —
animate_image instead defaults to 'frames' there, since a still photo is the whole
point of animate_image). The default xai/grok-imagine-video uses `mode` for TONE
(normal/fun/spicy), takes up to 7 reference pictures and does no frame placement —
always check describe_model(model).parameters.mode.

\`images` = reference frames (a bare string or a list); `videos` / `audios` feed models
that take them (e.g. a lip-sync avatar). `sound` is 'on'/'off' where supported. A `url`
from an earlier generate_*/media_status/list_gallery result can be passed straight back
in `images`/`videos`/`audios` as a reference — no download needed.

Video is slow: prefer `wait=False` and poll media_status(public_id). With `wait=True`
the server waits at most 10 minutes and then…

Input parameters:

- `aspect_ratio`
- `audios`
- `confirm` (boolean)
- `duration`
- `free_mode`
- `images`
- `max_price`
- `mode`
- `model` (string)
- `new_variant` (boolean)
- `parameters`
- `prompt` (string, required)
- `quality`
- `save_path`
- `sound`
- `videos`
- `wait` (boolean)

### `animate_image` (~689 tokens)

Animate a still picture into a video. `prompt` describes the MOTION, `source` is
the image (https URL or local path).

On bytedance/seedance-2.5-turbo, bytedance/seedance-2-fast, bytedance/seedance-2-mini,
wan/3-0-video and minimax/minimax-h3, `mode` defaults to `reference` on the backend —
which treats the photo as a style/subject reference, NOT the frame to animate. Since
that would defeat the point of this tool, leaving `mode` unset here auto-applies
\`mode='frames'` on those five models (a result warning says so); pass
\`mode='reference'` explicitly to get the reference behaviour instead. A SECOND picture
in `source` becomes the last frame only in `mode='frames'`. google/veo-3.1-fast(-relax)
already default to `frames` on the backend, so nothing changes there. Models carrying
the 'video:first_last_frame' capability (kwaivgi/kling-v3.0, bytedance/seedance-1.5-pro)
have no `mode` at all — two pictures in `source` are first/last frame by input order.
The default xai/grok-imagine-video takes up to 7 pictures as references (all
forwarded) and reads `mode` as TONE (normal/fun/spicy), never frames.
xai/grok-imagine-video-1.5 and minimax/hailuo-2.3-fast are image-to-video ONLY — a
call with no `source` picture is refused before anything is uploaded or charged.

Default `xai/grok-imagine-video` — budget, Russian voice-over, free quota; it adapts
the aspect ratio to the attached photo. For a talking/singing portrait use the
lip-sync app instead (generate_media with kling/ai-avatar, photo + audio); for a
trending dance from one photo use kwaivgi/kling-v2.6-motion-control with a preset.

Slow — prefer `wait=False` and poll media_status(); your MCP client may enforce a
shorter tool timeout than the server's 10-minute wait, and a wait that runs out returns
status 'progress' with a poll hint rather than an error. Money, `free_mode`, `save_path`,
\`max_price` and the duplicate guard (`new_variant`) behave exactly as in generate_image —
the video window is 20 minutes, since a clip…

Input parameters:

- `aspect_ratio`
- `confirm` (boolean)
- `duration`
- `free_mode`
- `max_price`
- `mode`
- `model` (string)
- `new_variant` (boolean)
- `prompt` (string, required)
- `quality`
- `save_path`
- `sound`
- `source` (required)
- `wait` (boolean)

### `generate_audio` (~1114 tokens)

Speech, dialogue or music from text. Costs ₽ (single digits for TTS, ~20₽ a song).

The model-specific parameter keys are filled in for you from `text`/`voice`/`style`:
\- `elevenlabs/v3` (default) — one narrator; `voice` is a NAME, expressive, good
  Russian. Omitting `voice` gives Rachel (female). Typically female: Rachel, Jane,
  Juniper, Arabella, Hope, Blondie, Priyanka, Alexandra, Monika; typically male:
  James, Bradford, Reginald, Austin, Kuon, Mark, Grimblewood (gender inferred from
  the studio's voice notes — verify with describe_model(model).voices).
\- `google/gemini-3.1-flash-tts` — `voice` like 'Kore'/'Puck'.
\- `elevenlabs/text-to-dialogue-v3` — several speakers: pass `text=""` and put the
  lines in `dialogue=[{"text": "...", "voice": "James"}, {"text": "...", "voice":
  "Arabella"}, …]`. IMPORTANT: this model accepts only 67 specific voices — NOT the
  full ElevenLabs catalogue elevenlabs/v3 draws from — and a voice outside that set
  (e.g. "Ellen", "Jane") is REFUSED here before anything is charged, not passed
  through to a paid failure. A known name from describe_model(model).voices is
  resolved to its ElevenLabs id for you; a raw id works too, as long as it is one of
  the 67.
\- `suno` — MUSIC. `text` is sung verbatim as the lyrics: write full lyrics and use
  [Verse] / [Chorus] tags. `style` = genre/mood; `voice` = 'female' (default) or
  'male' — suno has no named voices, any other value is dropped with a warning.

An unknown voice on elevenlabs/v3 or google/gemini-3.1-flash-tts is a warning, not a
refusal (those voice lists are a frontend snapshot that can lag a live catalogue) —
see describe_model(model).voices for the current ones. The dialogue model above is
the one exception: its 67-voice set is a closed provider enum, not a snapshot, so an
unaccepted voice there is a hard refusal instead.

\`parameters` is MERGED over the payload built above, so you can override one key and
keep the rest. The keys per model (describe_model(model).paramete…

Input parameters:

- `confirm` (boolean)
- `dialogue`
- `max_price`
- `model` (string)
- `new_variant` (boolean)
- `parameters`
- `save_path`
- `style`
- `text` (string, required)
- `voice`
- `wait` (boolean)

### `generate_media` (~756 tokens)

Call ANY model in the catalogue — including the "AI apps" that take no prompt at
all and are driven by attachments. Costs ₽ (a few to a few dozen per run).

\`images` / `videos` / `audios` / `named_images` accept a bare https URL/local file path
or a list of them; `named_images` fills the `named_inputs` slots describe_model lists
(an unlisted slot is refused before anything is uploaded). A `url` from an earlier
generate_*/media_status/list_gallery result can be passed straight back as a reference
— no download needed.

Task -> model -> what to pass:
\- swap a face: model="faceswap", named_images={"swap_image": face.jpg,
  "input_image": photo.jpg} — swap_image is the NEW face, input_image the target photo.
  Which face in a multi-face target gets replaced cannot be chosen: use a single-face
  target.
\- remove the background (transparent PNG): "background-remover-v1", images=[photo]
\- upscale a photo: "prunaai/p-image-upscale", images=[photo],
  parameters={"factor": "x2"|"x4"}
\- restore / enhance a photo: "enhance-photo", images=[photo]
\- animate a photo: "livephoto", named_images={"image": photo},
  parameters={"duration": 5|10} — livephoto reads a NAMED slot, not the plain image
  list, so images=[photo] would be uploaded and then ignored by the backend
\- picture -> SVG: "vectorize", images=[photo]; prompt -> SVG: "vector-image",
  prompt="..."
\- upscale a video: "bytedance/video-upscaler", videos=[clip],
  parameters={"quality": "720p"|"1080p"|"2k"|"4k"}
\- lip-sync a portrait to a voice: "kling/ai-avatar", images=[photo], audios=[voice]
\- trending dance from one photo: "kwaivgi/kling-v2.6-motion-control",
  images=[photo], preset="Ландыши"  (or videos=[your own reference clip])

\`preset` only applies to the dance model; pass a template name (describe_model lists
them), a filename, or your own https URL. Parameters are validated against the
catalogue before anything is uploaded or charged.

For a plain prompted edit on an edit-capable model use edit_image — the sam…

Input parameters:

- `aspect_ratio`
- `audios`
- `confirm` (boolean)
- `free_mode`
- `images`
- `max_price`
- `model` (string, required)
- `named_images`
- `new_variant` (boolean)
- `parameters`
- `preset`
- `prompt` (string)
- `save_path`
- `videos`
- `wait` (boolean)

### `media_status` (~168 tokens)

Poll the status/result of a media generation by its public_id.

Returns `status` ('progress' while running, 'success' when done, anything else means
it failed → the view also carries `failed: true`), `id` (the numeric id used by
delete_media / publish_media / like_media), `public_id`, `url`/`urls` (set on success),
and on failure `error` (readable reason, usually content moderation) plus
\`alternatives` — other models worth trying.

Polling also updates the duplicate guard: once a job started with wait=False reports
its outcome here, an identical generate_* call within the window is answered with that
outcome instead of a stale 'progress' snapshot.

Input parameters:

- `public_id` (string, required)

### `list_free_generations` (~136 tokens)

How many FREE generations remain per model TODAY, read LIVE.

Returns {"free_generations": {model_id: remaining today}, "limits": {model_id: daily
allowance}, "reset_at": ISO-8601 UTC when the daily quota comes back, "note": …};
\-1 means unlimited, a model absent from the maps has no free tier. The reading also
refreshes the cache get_balance serves from.

The generate_* tools use this quota automatically; pass free_mode=True to insist on it
(the backend then locks quality/duration to the cheapest option) or free_mode=False to
always pay.

### `delete_media` (~73 tokens)

Permanently DELETE one of your generations. Irreversible.

\`item_id` is the numeric `id` from a generation/gallery result (NOT `public_id`, the
string used by media_status / share_link / preview_media); every generate_* /
media_status result carries both.

Input parameters:

- `item_id` (string, required)

### `publish_media` (~89 tokens)

Publish (or unpublish) one of your generations to the public gallery. Returns the
updated record.

\`item_id` is the numeric `id` from a generation/gallery result (NOT `public_id`, the
string used by media_status / share_link / preview_media); every generate_* /
media_status result carries both.

Input parameters:

- `item_id` (string, required)
- `published` (boolean)

### `like_media` (~72 tokens)

Like a generation (yours or someone's public one).

\`item_id` is the numeric `id` from a generation/gallery result (NOT `public_id`, the
string used by media_status / share_link / preview_media); every generate_* /
media_status result carries both.

Input parameters:

- `item_id` (string, required)

### `share_link` (~64 tokens)

Public share URL for a generation (no API call) -> https://most-ai.com/s/{public_id}.

This only formats the link — it does not check that the item exists, that it succeeded
or that it is published.

Input parameters:

- `public_id` (string, required)

### `download_media` (~230 tokens)

Download a generated file (image/video/audio) to local disk; return its binary path.

\`url` is a result link from generate_* / media_status / list_gallery. `dest_path` may be a
file path or a directory; the default is absolute — `$MOSTAI_HOME/downloads`, i.e.
\`~/.mostai-mcp/downloads` — and does not depend on the working directory. A RELATIVE
\`dest_path`, however, resolves against the server's working directory, which is not the
caller's folder: under the shared HTTP hub the server runs once per machine, so pass an
absolute path whenever the file must land somewhere specific. The MostAI cookie is sent
only if the URL is on the app host. Returns {path, bytes, content_type, url}.

Use this when you need the raw file (e.g. to upload into an ad campaign); use the result
\`url` directly when a stored link is enough (the file is hosted for a long time).

Input parameters:

- `dest_path`
- `url` (string, required)

### `preview_media` (~118 tokens)

Return a generated IMAGE inline so you can actually SEE it and judge it.

Accepts a result URL or a public_id (from generate_* / list_gallery). For an image, shows
the image itself; for a video, shows its thumbnail. Use this to review a result before
downloading it or pushing it into a campaign. (Audio has no visual preview.)

The image is returned as tool output and is visible to the user in the conversation
too — there is no private preview.

Input parameters:

- `url_or_public_id` (string, required)

### `list_gallery` (~123 tokens)

List recent generations. `success_only` keeps only finished ones; `tag` filters by tag;
\`public=True` browses the public/explore feed instead of your own gallery.

Items come most recent first; each carries `id` (delete/publish/like), `public_id`
(media_status/share_link/preview_media), `status`, `model`, `prompt`, `url`/`urls` and
\`error`.

Input parameters:

- `limit` (integer)
- `public` (boolean)
- `success_only` (boolean)
- `tag`

Output parameters:

- `result` (array)

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/most-ai-com-mostai-mcp/mostai-mcp#diagnostics

## Score history

- 2026-09-22: 50
- 2026-09-21: 49
- 2026-09-20: 49
- 2026-09-19: 48
- 2026-09-18: 48
- 2026-09-17: 47
- 2026-09-16: 47
- 2026-09-15: 46
- 2026-09-14: 46
- 2026-09-13: 45
- 2026-09-12: 60
- 2026-09-11: 42
- 2026-09-10: 42
- 2026-09-09: 57
- 2026-09-08: 57
- 2026-09-07: 57
- 2026-09-06: 57
- 2026-09-05: 57

## Common questions

### What is the io.github.most-ai-com/mostai-mcp server?

io.github.most-ai-com/mostai-mcp is listed in the public MCP registry as io.github.most-ai-com/mostai-mcp. Generate images, video, music, speech and text with 60+ models through your MostAI account. This page covers its PyPI package (mostai-mcp).

### Is the io.github.most-ai-com/mostai-mcp server safe to use?

io.github.most-ai-com/mostai-mcp scores 50 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 22 September 2026. 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 io.github.most-ai-com/mostai-mcp server expose?

io.github.most-ai-com/mostai-mcp exposes 24 tools: list_models, describe_model, get_balance, spending_status, whoami, and 19 more. Their descriptions and schemas cost roughly 7,877 tokens of context every time the server is loaded.

### Is the io.github.most-ai-com/mostai-mcp server still maintained?

io.github.most-ai-com/mostai-mcp is still listed as active in the MCP registry. We last reached this channel on 22 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

## Links

- PyPI project: https://pypi.org/project/mostai-mcp/
- Socket report: https://socket.dev/pypi/package/mostai-mcp
- Changelog RSS feed: https://verifymcp.io/servers/most-ai-com-mostai-mcp/mostai-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/most-ai-com-mostai-mcp/mostai-mcp.json
- HTML version of this page: https://verifymcp.io/servers/most-ai-com-mostai-mcp/mostai-mcp