Corent MCP Server

Give any AI agent the ability to generate images, videos, voice, and text through the Corent API, one key, automatic model routing, provider fallback built in.

Tools

| Tool | What it does | |---|---| | plan | Describe a request in plain language; Corent returns the plan (image vs video, tier, settings) + cost estimate, without generating | | create | Describe what you want + a spend ceiling; Corent decides everything and generates one image or one clip (the "zero decisions" path) | | plan_film | One sentence → a film plan: title, characters, every scene with its dialogue, and the price. Free, kept for 24 hours | | make_film | Make the planned film, capped by max_cost_cents. Returns a film_id; about 15 to 30 minutes | | get_film | The film's stage and, when done, video_url: one finished video with sound | | cancel_film | Stop a film that has not finished. A cancelled film is not billed | | generate_image | Text → image, synchronous, returns a permanent URL. Takes reference_image_urls for character and product consistency | | generate_video | Text, image, or references (@Image 1, @Video 1, @Audio 1) → video, async job. return_last_frame hands back the final frame to chain shots | | edit_video | Change something in a finished clip (add, remove, replace); keeps its length and shape | | extend_video | Continue a finished clip forward or backward | | generate_speech | Text → spoken audio, synchronous | | generate_text | Prompt or full conversation → text from a frontier language model. Supports tool calling and JSON mode | | generate_image_batch | Up to 50 images in one call, async | | generate_video_batch | Up to 50 clips in one call, async; items take the same reference fields as generate_video | | get_batch | Progress of a submitted batch | | list_models | The direct-access menu: every model that can be pinned by name (corent-*), with quality and live status | | list_tiers | The tier menu: prices, shapes, video resolutions, and which tiers accept reference images or render sound | | list_voices | The voices generate_speech accepts, with previews and descriptors | | cancel_job | Stop a running job and release its money hold. Costs nothing | | get_job | Poll a job until completed | | get_balance | Balance, holds, and what a new request can actually spend | | get_status | Live tier health | | upscale_image | Make an existing image bigger and sharper. Flat price, no tier | | remove_background | Cut the subject out, returns a PNG with a real transparent background | | inpaint_image | Regenerate only the white region of a mask; every pixel outside it stays byte-for-byte unchanged | | list_media | What the account already made: the last 100 jobs, filtered by type and prompt keyword, so a result can be reused instead of paid for again | | upload_image | Base64 in, public https URL out. Use it as image_url, mask_url, or a reference in the other tools (max 25 MB) |

Every tool description is under 400 characters and every tool carries readOnlyHint / destructiveHint / openWorldHint annotations plus the ChatGPT openai/toolInvocation status strings, so the server can be listed as a ChatGPT app as well as a Claude connector.

Prompts (recipes)

The server also registers six MCP prompts. Each is a step list over the tools above: plan, confirm the budget with the user, stills with references, clips, narration, poll. Hosts that support prompts show them as slash commands; the same six ship as markdown in skills/ for publication as a skills repo.

| Prompt | Arguments | What it makes | |---|---|---| | product-ugc-reel | product_url, brief, budget_usd | Vertical creator-style reel for one product | | character-series | character, scenes, budget_usd | One consistent character across many scenes and clips | | storyboard-to-clip | storyboard, style, budget_usd | Numbered storyboard to stills, clips chained through last frames, and narration | | ad-variations | concept, count, product_url | Many versions of one ad visual, in a single batch | | faceless-explainer | topic, duration_s, budget_usd | Narrated explainer with no presenter | | make-a-film | brief, duration_s, budget_usd | One sentence to one finished film with characters, dialogue and sound |

Prices the recipes quote before spending: image premium ~7c, video premium ~52c per clip, pro ~84c per clip, speech ~25-30c per started block of 1,000 characters.

The plan and create tools are the agent-native path: an agent says what it wants ("a 10s vertical clip of a sunrise for TikTok") and Corent picks image-vs-video, the tier, aspect ratio, and duration, the agent never manages models. create enforces a per-call spend ceiling so an autonomous agent can't overspend.

Films: one sentence to a finished video

Describe a film in one sentence ("a 50 second parody where 5 founders start a startup, know nothing, and the AI part is easy because they used Corent") and Corent makes the whole thing. It writes the script, creates the characters once, shoots every scene with those same characters speaking their lines, checks each scene and reshoots a bad one once, then joins everything into one video with sound.

1. plan_film with the brief (and optionally duration_s 10 to 120, aspect_ratio, resolution, language). Free. Returns the title, the characters, every scene with its dialogue, estimated_cost_cents and a range. Show it to the user and get a yes.
2. make_film with plan_id and max_cost_cents a little above the estimate. It returns a film_id at once.
3. get_film every 60 seconds: queued, writing, casting, shooting, checking, editing, then completed with video_url. In hosts that support MCP Apps the finished film plays inline, like generate_video.

The price is shown before anything is paid, the charge never goes above max_cost_cents, and a film that fails or is cancelled (cancel_film) is not billed. A 50 second 720p film with five characters costs roughly $10 to $20 and takes about 15 to 30 minutes.

plan and create send a story with several characters, or anything over about 30 seconds, to plan_film: create makes one image or one clip, never a film.

When the user names a specific model

All four generate_* tools also take an optional model: pin an exact model from list_models and Corent runs that one, never a substitute (if it can't deliver, the call fails and nothing is billed). Use it only when the user asked for a particular model by name, otherwise omit it and let Corent route to the best fit for the prompt, which is what the tiers are for.

Every name in the menu is spelled corent-*: corent-flux-schnell, corent-seedance-2.0, corent-eleven-multilingual-v2, corent-claude-opus-5, and that is the name the receipt echoes back. Pass one back verbatim.

generate_text is the language-model lane: it puts every frontier lab on the same key and the same bill, so an agent can get a named model's answer or a second opinion from another lab without the user holding that lab's account. Pass messages instead of prompt to continue a conversation or feed tool results back, and tools / response_format for function calling and JSON.

Keeping a character or product consistent

generate_image takes reference_image_urls: 1 to 4 public https images that the prompt is applied as an edit of, so the same face, character, or product survives into a new scene. Use it whenever the user wants "the same person again", a product placed somewhere, or a matching series. Edit-capable models sit at pro and up, so pass tier pro / max_pro, or no tier at all: air, lite and premium are refused with a message saying so. (Check list_tiers -> supports_reference_images for the live list.)

What the generate tools can ask for

generate_image takes a seed (so a picture can be re-rendered and tweaked), a negative_prompt, a source_image_url with strength to start from an existing picture, transparent for logos and cutouts, an explicit width and height, output_format, and n for several versions at once. n is n real renders at full price, so confirm before spending on more than a couple.

generate_video takes audio for native sound (true routes only to models that actually render it, so a silent model can never quietly serve the ask), end_image_url for the frame to finish on, a camera move, negative_prompt, seed and fps.

Video with references, edits, extensions and chained shots

On corent-seedance-2.5 generate_video also takes reference_image_urls (up to 30), reference_video_urls (up to 10) and reference_audio_urls (up to 10). The prompt points at them as @Image 1, @Video 1, @Audio 1 in the order given, so "the character in @Image 1 walks through the market" keeps that character. task says what to do with them: auto (default), reference, edit or extend. edit_video and extend_video are the two-argument versions of the last two: give them a prompt and the clip URL and they set the rest.

return_last_frame: true stores a PNG of the final frame and returns it as last_frame_url on the finished job; pass it as the next clip's image_url and the action continues without a cut. That is how a longer scene is built from 5 to 10 second clips.

The API rules, mirrored here so nothing is spent on a request it would refuse: first/last frame (image_url / end_image_url) and reference_* cannot be mixed; an edit keeps the source length, so omit duration_s; on first/last frame, edit and extend the clip keeps the source shape, so omit aspect_ratio or pass adaptive. list_models reports supports_reference_images, max_reference_images, supports_video_edit, supports_video_extend and supports_last_frame per video model; an incapable model answers 400.

The supplier rejects photos of real people as references; characters generated inside Corent are accepted, so make the person with generate_image first and reference that.

generate_speech takes stability, similarity, style, speed and language. Call list_voices first whenever the user wants a particular sounding narrator: voice_id cannot be guessed.

Anything the chosen model could not honour comes back in meta.unsupported_options, so an ignored setting never reads as an applied one. enhance_prompt: false sends the user's wording verbatim.

Editing what already exists

upscale_image and remove_background take a public https URL and return a new one. inpaint_image takes the image, a same-size black-and-white mask (white = regenerate, black = keep) and a prompt for the masked region; unlike reference_image_urls, which re-creates a likeness, the pixels outside the mask are your own file, unchanged. upload_image turns a local file into a URL any of these accept, and list_media finds an earlier result by prompt keyword ("the beach one") so it can be reused rather than re-generated.

Spending safety

Every money-spending call carries an Idempotency-Key, and a 429 or 5xx is retried under that same key, so a retry replays the original job instead of buying a second one. Batches bill per item: a 30-item image batch costs 30 generations, so check get_balance first.

Setup

Get an API key at corent.tech, then add to your MCP client config:

{
  "mcpServers": {
    "corent": {
      "command": "npx",
      "args": ["-y", "corent-mcp"],
      "env": { "CORENT_API_KEY": "co_live_..." }
    }
  }
}

For Claude Code: claude mcp add corent -e CORENT_API_KEY=co_live_... -- npx -y corent-mcp

Hosted server (no install)

The hosted server at https://mcp.corent.tech/mcp uses the Streamable HTTP transport and supports OAuth: in claude.ai (Settings → Connectors → Add custom connector) just enter the URL with no key, you'll be sent to a Corent page to approve access. Your API key is verified once, sealed into an encrypted connection token, and never shown to the client. Revoking the key in your dashboard disconnects the client instantly.

Non-OAuth clients can instead pass an API key in the Authorization header:

{
  "mcpServers": {
    "corent": {
      "url": "https://mcp.corent.tech/mcp",
      "headers": { "Authorization": "Bearer co_live_..." }
    }
  }
}

X-Corent-Api-Key: co_live_... is accepted as an equivalent header.

Smithery note: for compatibility with Smithery, the hosted server also accepts the key via query parameters (?corent_api_key=... or Smithery's base64 ?config=). Avoid this form anywhere else, URLs can be logged by proxies, gateways, and access logs, which would expose your key. Prefer the Authorization header.

Development

npm install
npm run build
CORENT_API_KEY=... node dist/index.js

The hosted entrypoint (dist/http.js) additionally needs MCP_TOKEN_SECRET (random string; encrypts OAuth tokens, rotating it logs every connector out) and optionally MCP_PUBLIC_URL (defaults to https://mcp.corent.tech). Set OPENAI_APPS_CHALLENGE_TOKEN to serve the ChatGPT Apps domain verification at /.well-known/openai-apps-challenge (404 while unset).