Skip to main content
Glama

Replicate MCP Server

Smithery Ko-fi

A universal, cross-platform MCP server that gives any MCP client — Claude Desktop, the claude.ai web app (Connectors), Cursor, Cline / Continue in VS Code, or your own application — native access to the full Replicate catalog: image generation, video, music, speech, upscaling, segmentation, LLMs, voice cloning, 3D, lipsync — anything Replicate hosts.

It speaks both transports: stdio (the standard for local desktop/editor integrations) and HTTP/SSE (for remote/web clients and your own services).

Once connected to your MCP client, you can simply ask:

"Generate a cinematic shot of a lighthouse in a storm, 21:9" "Write a 30-second synthwave track" "Make a 5-second video of a paper airplane flying through a city" "Read this paragraph in a British male voice" "Upscale this image 4x"

…and the assistant calls the right Replicate model, waits for the result, and (on local/stdio setups) downloads the output to your machine.


Install

Fastest — one-click via Smithery: open the server page and copy the Install snippet for your client (Claude, Cursor, VS Code, Cline, Windsurf, …). It wires the server in and prompts for your Replicate token. (Routes through Smithery's hosted gateway — easiest, zero local setup.)

Token-private — npm + stdio (your Replicate token never leaves your machine):

npx -y replicate-mcp-server

…or drop it into any MCP client's config (full walkthrough under Installation).

Claude Desktop one-file install: download the latest .mcpb from Releases and drag it onto Claude Desktop.

Already running (bring your own token): https://replicate-mcp.sena-labs.dev/mcp — HTTP/SSE, multi-tenant; pass your token in the x-replicate-api-token header.

Once connected, try the example prompts below.


Related MCP server: multimodal-mcp

Try it

Once your client is connected, ask in plain language — the assistant picks the right tool, waits for the result, and downloads the output locally:

"Generate a cinematic shot of a lighthouse in a storm, 21:9" "Which is the cheapest model for a 5-second video? Then use it." — recommend → generate "Make 4 logo variations of a fox, flat vector style" — batch (concurrent) "Transcribe this audio, summarise it, then read the summary aloud" — DAG pipeline "Upscale this image 4×" · "Write a 30-second synthwave track" · "Read this in a British male voice" "Kick off a Flux LoRA fine-tune on my dataset and tell me when it's done" — training

Discovery tools (replicate_recommend_model, replicate_search_models, replicate_estimate_cost) and the 5 built-in workflow prompts help it chain multi-step jobs without you naming models.


What's inside

36 tools and 66 curated models, designed to be both ergonomic for common cases and fully open-ended for everything else. Every generate/run tool waits for completion and auto-downloads the outputs to your machine — you ask once and get back local files, not a job id to babysit:

Curated generation tools

Tool

Purpose

replicate_generate_image

Text → image. Curated: Flux Schnell / Dev / Pro / 2-Max, SD 3.5, Recraft v3 / v4.1, Seedream, Ideogram v2, Imagen 3.

replicate_generate_video

Text (or image) → video. Curated: Kling Pro, Minimax, Hunyuan, Luma Ray, Wan 2.2, Grok Video, Seedance.

replicate_generate_audio

Text → music / songs. Curated: MusicGen, ACE-Step (full songs with lyrics), Riffusion, MiniMax Music.

replicate_generate_speech

Text → speech (TTS). Curated: Kokoro, Minimax Speech, Chatterbox, Gemini TTS, Grok TTS.

replicate_chat

Text → text via LLM. Curated: Llama 3.1 405B, Llama 3 70B / 8B, Mistral 7B, Mixtral 8x7B, DeepSeek-R1.

replicate_vision

Image → text. Curated: LLaVA 13B / 1.6 34B, BLIP-2, Qwen2-VL.

replicate_upscale_image

Image → higher-res image. Curated: Real-ESRGAN, Clarity Upscaler, Clarity Pro, SwinIR, GFPGAN.

replicate_remove_background

Image → transparent PNG. Curated: rembg, BiRefNet, BRIA RMBG.

replicate_transcribe_audio

Audio/video → text. Curated: Whisper, Distil-Whisper, WhisperX (diarization), ElevenLabs Scribe.

replicate_inpaint

Mask-based image edit. Curated: Flux Fill Pro, SD inpaint, Ideogram v2 edit.

replicate_segment

Image → mask. Curated: SAM 2, Grounded-SAM (text-prompt).

replicate_embed_text

Text(s) → vector embeddings. Curated: BGE, Jina v3, MPNet.

Voice, 3D, and avatar tools

Tool

Purpose

replicate_clone_voice

Text + reference sample → speech in a cloned voice. Curated: XTTS v2, OpenVoice v2.

replicate_generate_3d

Text or image → 3D mesh (GLB/OBJ). Curated: Hunyuan 3D, Rodin, TripoSR.

replicate_lipsync

Portrait + text/audio → lip-synced talking video. Curated: Video Avatar, SadTalker.

Orchestration tools

Tool

Purpose

replicate_batch_start / replicate_batch_status

Run up to 50 predictions concurrently as a background job; poll progress + results.

replicate_pipeline_start / replicate_pipeline_status

Run a DAG of predictions — independent steps in parallel, downstream steps wired via "$stepId.urls[0]" template refs.

replicate_recommend_model

Rank curated models in a category by priority (speed / cost / quality / balanced) with cost estimates — advises which model to use.

replicate_refresh_models

Discover popular Replicate models not yet in the curated registry.

Fine-tuning (trainings)

Tool

Purpose

replicate_create_training

Kick off a fine-tune / training run on a trainable base model (e.g. a Flux LoRA) with your dataset + parameters.

replicate_get_training

Poll a training by id (status, logs, resulting model version).

replicate_list_trainings

List your recent training runs (id, model, status, timestamps).

replicate_cancel_training

Cancel an in-progress training run by id.

Deployments

Tool

Purpose

replicate_list_deployments

List your Replicate deployments (owner/name, current model + version).

replicate_get_deployment

Inspect one deployment (model, version, hardware, autoscaling min/max).

replicate_run_deployment

Run a prediction against a deployment — waits for completion and auto-downloads the outputs, same as the curated generate tools.

Prediction management + cost

Tool

Purpose

replicate_list_predictions

Recent prediction history (id, model, status, timestamps).

replicate_cancel_prediction

Cancel an in-progress async job by id.

replicate_estimate_cost

Pre-call USD estimate from a curated price table.

Generic / discovery tools

Tool

Purpose

replicate_run_model

Run any Replicate model with arbitrary inputs (escape hatch for anything not covered by a curated tool).

replicate_search_models

Free-text search across the Replicate catalog.

replicate_get_model_schema

Get the OpenAPI input schema for any model.

replicate_get_prediction

Poll a long-running prediction (videos, long songs).

replicate_upload_file

Upload a file to Replicate storage (by local file_path or base64_data / data URI); returns a URL to feed into other tools.

Outputs:

  • Image / video / audio: downloaded to ~/Downloads/replicate-mcp/<model>/<prediction_id>/ (configurable). Local paths and original Replicate URLs are both returned. For images, the response also includes an inline base64 preview (sized to stay under Claude Desktop's 1 MB tool-result limit; larger images fall back to the URL embed) plus three embed snippets (<details>-wrapped iframe viewer with Save button, responsive <img>, or markdown image) so the chat client can render the result inline at full size.

  • Text (LLM, vision, classifier): the model's reply is surfaced in text_output and printed at the top of the tool response so Claude can read it directly.

Editing an image you have on hand

The editing tools (replicate_upscale_image, replicate_inpaint, replicate_remove_background, replicate_vision, image-to-video, lipsync, 3D-from-image) all take a URL. To turn a file into a URL, use replicate_upload_file:

  • You have a local path (Claude Desktop): replicate_upload_file({ file_path: "C:/Users/you/photo.jpg" }) → URL → pass to the editing tool. If an image is dragged/pasted into the chat, save it to disk first — the server cannot read chat attachments directly, and Claude Desktop cannot reproduce a large image's exact bytes as a tool argument.

  • You have the bytes in memory (claude.ai web with a code container): read the uploaded file in the container, base64-encode it, then replicate_upload_file({ base64_data: "data:image/png;base64,..." }) → URL → editing tool. base64_data accepts a bare base64 string or a full data:<mime>;base64,... URI.

  • You already have a URL: pass it straight to the editing tool — no upload needed.


Why this over the official Replicate MCP?

Replicate ships its own official MCP (replicate-mcp on npm, hosted at mcp.replicate.com). It's a great, free, always-up-to-date 1:1 bridge to the REST API — Stainless-generated from Replicate's OpenAPI spec, ~37 generic tools that mirror each endpoint (account, collections, deployments, files, hardware, models, predictions, trainings, webhooks), plus a --tools=dynamic mode and a Deno "Code Mode" sandbox.

This server is built for a different job. The official MCP is a thin, generic API bridge: to make an image you call create_predictions with a raw model id and raw input JSON, and the LLM has to look up each model's input schema itself; it returns starting and does not wait or download (you opt into Prefer: wait, capped at 60s, then poll manually). This server is a batteries-included creative studio: task-oriented tools with sane defaults, a curated model registry, built-in orchestration, and cost awareness — every generate/run tool waits for completion and auto-downloads the outputs locally.

Axis

Official Replicate MCP

This server (sena-labs)

Philosophy

Thin generic API bridge (1:1 REST)

Task-oriented creative studio

Tools

~37 generic REST tools (+ dynamic/code modes)

36 task tools (generate_image/video/audio/speech/3d, clone_voice, lipsync, upscale, inpaint, segment, remove_background, transcribe, vision, chat, embed)

Media helpers

None — raw predictions.create + raw input JSON

Purpose-built tools with sane defaults (aspect ratio, etc.)

Run UX

Returns starting; opt-in Prefer: wait (≤60s) then manual poll

Waits for completion AND auto-downloads outputs locally

Model curation

None — you supply the model + look up its schema yourself

60+ curated models + recommend_model + smart routing + search_models + get_model_schema

Orchestration

None

Async batch (batch_start/status) + DAG pipelines (pipeline_start/status)

Cost

None

estimate_cost pre-flight USD estimate

Fine-tuning + deployments

Yes (generic REST)

Yes — create/get/list/cancel_training + list/get/run_deployment (run waits + downloads)

Extras

OAuth, auto-sync to API

5 workflow prompts + 2 MCP resources (catalog + capabilities)

REST breadth

Broader raw coverage (collections, files, hardware, webhooks, account)

Focused on creative tasks + the orchestration/cost layer on top

Hosted / official

Official, free, hosted at mcp.replicate.com with OAuth, auto-synced

Self-hostable, multi-tenant (per-user token), stdio + HTTP/SSE

In short: the official MCP is the right tool if you want exhaustive, always-current raw REST access (and a free hosted endpoint with OAuth). This server is the right tool if you want a curated, orchestrated, cost-aware creative workflow where you describe what you want and get finished files back — no schema lookups, no manual polling, no manual downloads. They're complementary: use the official one for full-surface API plumbing, use this one for getting creative work done.


Prerequisites

  • Node.js ≥ 20 (uses native fetch and Web Streams)

  • A Replicate account with an API token: https://replicate.com/account/api-tokens

  • An MCP client — e.g. Claude Desktop (macOS/Windows/Linux), the claude.ai web app, Cursor, Cline / Continue (VS Code), or any custom MCP host. The walkthrough below uses Claude Desktop as the example; the same command / args / env block works in any client's MCP config. For remote/web clients, see HTTP / SSE transport.


Installation

1. Clone and build

git clone <this-repo> replicate-mcp-server
cd replicate-mcp-server
npm install
npm run build

This produces dist/index.js, which is the server entry point.

2. Get your Replicate API token

  1. Go to https://replicate.com/account/api-tokens

  2. Click Create token

  3. Copy the token (starts with r8_...)

3. Connect it to your MCP client (Claude Desktop shown)

The MCP command / args / env block below is identical across clients — only the location of the config file differs (Cursor: ~/.cursor/mcp.json; Cline/Continue: the extension's MCP settings; custom hosts: your own launcher). For Claude Desktop, find your config file:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

  • Windows: %APPDATA%\Claude\claude_desktop_config.json

  • Linux: ~/.config/Claude/claude_desktop_config.json

Add the replicate entry (merge with anything already there):

{
  "mcpServers": {
    "replicate": {
      "command": "node",
      "args": ["/ABSOLUTE/PATH/TO/replicate-mcp-server/dist/index.js"],
      "env": {
        "REPLICATE_API_TOKEN": "r8_your_token_here"
      }
    }
  }
}

⚠️ Use the absolute path to dist/index.js. Tildes (~) and relative paths don't work in this config.

Optional: set a custom download directory:

"env": {
  "REPLICATE_API_TOKEN": "r8_...",
  "REPLICATE_DOWNLOAD_DIR": "/Users/you/my-replicate-outputs"
}

4. Restart Claude Desktop

Fully quit and reopen Claude Desktop. You should see "replicate" listed in the tools panel (the hammer icon at the bottom of the chat).


VS Code (native MCP)

VS Code has built-in MCP support. This repo ships a ready-to-use .vscode/mcp.json that runs the published npm package locally and prompts for your token (stored masked, never written to the file):

{
  "inputs": [
    { "type": "promptString", "id": "replicate_token", "description": "Replicate API token", "password": true }
  ],
  "servers": {
    "replicate": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "replicate-mcp-server"],
      "env": { "REPLICATE_API_TOKEN": "${input:replicate_token}" }
    }
  }
}

Open the file in VS Code and click Start above the replicate server (or run MCP: List Servers). VS Code asks for the token once.

Note on the Smithery "One-Click Install": it wires VS Code to Smithery's hosted gateway (mcp.smithery.run), which runs the server on Smithery's infrastructure and would route your personal Replicate token through it on every call. For a personal API token, prefer the local stdio config above — the token never leaves your machine.


Usage examples

Once connected, just talk to your assistant naturally (examples use Claude phrasing, but any MCP-capable assistant works):

Images

Generate an origami fox in a misty forest, 16:9 aspect ratio.

High-quality images with text

Make a logo for a coffee shop called "Crema" — use Recraft.

Video

Create a 5-second video of a paper airplane gliding through a neon-lit city. Use Kling Pro.

(Videos take 1–5 minutes. If the call times out, Claude will automatically poll with replicate_get_prediction.)

Music

Write a 20-second instrumental synthwave loop with a heavy bassline.

Songs with lyrics

Use the ACE-Step model to generate a sad indie-folk song with these lyrics: [...]

Speech

Read this paragraph in a British female voice: [...]

Chat with an LLM

Ask Llama 3 70B to explain quantum entanglement in two sentences.

Image understanding

Look at this photo [URL] and tell me what objects are in the foreground.

Upscale

Upscale this image 4x with Real-ESRGAN: [URL]

Background removal

Cut the background out of this product photo: [URL]

Anything else

Search Replicate for "speech to text", then transcribe this audio: [URL]

(Claude picks Whisper via replicate_search_models → replicate_run_model.)


How async predictions work

Image generation usually finishes in seconds. Video, long music, and some heavy models can take minutes. The server handles this transparently:

  1. You call replicate_generate_video.

  2. The server waits up to timeout_ms (default 5 minutes) by polling Replicate every 2 seconds.

  3. If it finishes in time → you get URLs and local paths.

  4. If it doesn't → you get back pending: true and a prediction_id. Claude can call replicate_get_prediction later to retrieve the result.

You can bump timeout_ms up to 30 minutes if you want to wait inline:

Generate a 10-second Hunyuan video. Wait up to 20 minutes.


Configuration

Environment variable

Default

Purpose

REPLICATE_API_TOKEN

(required)

Your Replicate API token.

REPLICATE_DOWNLOAD_DIR

~/Downloads/replicate-mcp

Where to save generated files.


Costs

Replicate charges per second of compute, varying by model. Approximate costs:

  • Flux Schnell image: ~$0.003

  • Flux Dev image: ~$0.025

  • Flux 1.1 Pro image: ~$0.04

  • Kling 1.6 Pro 5-second video: ~$0.45

  • MusicGen 30-second clip: ~$0.05

  • Kokoro TTS: ~$0.001 per request

  • Llama 3 70B chat: ~$0.001 per 1K tokens

  • LLaVA 13B vision: ~$0.001 per image

  • Real-ESRGAN 4x upscale: ~$0.003 per image

See https://replicate.com/pricing for current rates and your billing dashboard for usage.


Troubleshooting

"REPLICATE_API_TOKEN environment variable is not set" You haven't put the token in the env block of your Claude Desktop config. Double-check the JSON and restart Claude Desktop.

"Server disconnected" in Claude Desktop Usually a path problem. Make sure the path to dist/index.js is absolute and the file exists. Test it manually:

REPLICATE_API_TOKEN=r8_... node /ABSOLUTE/PATH/dist/index.js

You should see replicate-mcp-server v1.0.0 ready. API token detected. on stderr. Press Ctrl+C to quit.

A model isn't in the curated list Just use its full identifier: model: "stability-ai/sdxl" works the same way. Or use replicate_search_models to find one.

Need a specific version of a model Use the owner/name:version_hash form: model: "black-forest-labs/flux-schnell:bf53bdb93d739c9c915091cfa5f49ca662d11273a5eb30e7a2ec1939bcf27a00".

Downloaded files are missing Check REPLICATE_DOWNLOAD_DIR. Files are organised as <dir>/<sanitized-model>/<prediction-id>/output-N.<ext>.


Deploy as platform (v3.0+)

Beyond a single local stdio client, the server also runs as a multi-user platform — HTTP/SSE transport (for claude.ai web Connectors, remote editors, and custom apps), multi-token pool, webhook-driven async completion, Docker, npm distribution.

HTTP / SSE transport

Run the server as an HTTP service instead of stdio:

# Local-only, no auth — for development.
node dist/index.js --http --port 8088

# LAN-exposed with Bearer auth — behind a private network.
node dist/index.js --http --host 0.0.0.0 --port 8088 --api-key your-shared-secret

Clients POST JSON-RPC to http://host:port/mcp with:

Authorization: Bearer your-shared-secret
Content-Type: application/json
Accept: application/json, text/event-stream
Mcp-Session-Id: <set by server on initialize, echoed on follow-ups>

Health probe (no auth): GET /health → {"status": "ok"}.

npm install (when published)

npx replicate-mcp-server --http --port 8088 --api-key SECRET
# or as a Claude Desktop launcher:
npx replicate-mcp-server

Docker

docker build -t replicate-mcp-server .
docker run --rm \
  -e REPLICATE_API_TOKEN=r8_... \
  -e LOG_LEVEL=info \
  -p 8088:8088 \
  replicate-mcp-server

The default CMD starts in HTTP mode on 0.0.0.0:8088. Add --api-key via docker run ... replicate-mcp-server --http --api-key SECRET if you expose the port beyond a private network.

Multi-token round-robin pool

For team / multi-tenant deployments, give the server multiple Replicate accounts to spread rate-limit headroom:

REPLICATE_API_TOKEN_POOL=r8_account_a,r8_account_b,r8_account_c \
  node dist/index.js --http --port 8088

Each Replicate API call rotates through the pool. Falls back to single REPLICATE_API_TOKEN if only one configured.

Webhook receiver (event-driven completion)

If the server is reachable from the public internet, you can replace polling with webhook callbacks:

REPLICATE_WEBHOOK_PUBLIC_URL=https://your.domain/webhook \
REPLICATE_WEBHOOK_PORT=8089 \
  node dist/index.js --http --port 8088

Replicate POSTs prediction completion to the public URL; the server resolves the awaiting tool call without polling. Per-prediction random token authenticates each callback.

Smithery listing

This server is live on Smithery: smithery.ai/server/sena-labs/replicate-mcp-server — scanned (36 tools, 5 prompts, 2 resources) and one-click installable into Claude, Cursor, VS Code, Cline, Windsurf, and other MCP clients. smithery.yaml defines the install-time config UI (token, optional pool, log level, download dir).

claude.ai web Connector

For listing as a Connector inside the claude.ai web app:

  1. Deploy the server publicly with HTTPS (Render / Fly.io / Cloudflare / bare VPS behind a TLS-terminating reverse proxy).

  2. Register the MCP HTTP endpoint at https://console.anthropic.com/settings/connectors.

  3. Users add it from claude.ai → Settings → Connectors → Add custom.

Anthropic's Connector review is manual — provide the OAuth flow / API key input form they require, plus the public /mcp URL.


Architecture

src/
├── index.ts        # MCP server, tool registration, response formatting (handler factory)
├── replicate.ts    # API client, polling, output extraction (URLs + text), file download with retry
├── schemas.ts      # Zod schemas for tool inputs (with .strict())
├── models.ts       # Curated model registry per category (8 categories)
└── constants.ts    # Shared constants (timeouts, paths, character limits)

test/
├── stdio-test.mjs       # End-to-end MCP handshake + tool registration test (response correlation)
└── unit/                # node:test unit suites for pure helpers
    ├── extract-urls.test.mjs
    ├── extract-texts.test.mjs
    ├── infer-filename.test.mjs
    └── sanitize.test.mjs

The server uses the stdio transport (standard for local Claude Desktop integrations) and the modern registerTool API of the MCP TypeScript SDK. All tool inputs are validated by Zod schemas with .strict() enforcement — no unknown parameters slip through.

The 8 curated generation tools share a single makeGenerationHandler factory; each tool only declares how it maps its specific input fields onto the Replicate request body. Output URLs are extracted by recursively walking the prediction's output field, which can be a string, an array, a nested object, or any combination. Text outputs (from LLM / vision / classifier models) are surfaced through the same walker so non-URL strings appear in the response. Files are streamed to disk using Node's stream/promises.pipeline() so multi-GB videos don't blow up memory. Downloads retry once on transient failures (network error or 5xx) with exponential backoff; 4xx errors fail fast.

Testing

npm run build
node --test test/unit/*.test.mjs    # 43 unit tests on pure helpers
node test/stdio-test.mjs            # End-to-end MCP handshake + tool/list + tool/call sanity check

Support & contact

If this project is useful to you, consider supporting its development:

☕ ko-fi.com/senalabs


Trademarks & disclaimer

This is an independent, community-built project. It is not affiliated with, endorsed by, sponsored by, or officially connected to Replicate, Inc.

  • "Replicate" and the Replicate logo are trademarks of Replicate, Inc. This server is an interoperability client for Replicate's public HTTP API; the name is used descriptively (nominative fair use) to indicate compatibility — not to imply origin or endorsement. For Replicate's own official MCP server, see replicate.com/docs/reference/mcp.

  • Built on the Model Context Protocol (MCP), the open standard created by Anthropic.

  • Model names referenced (FLUX, Recraft, Whisper, Llama, etc.) are trademarks of their respective owners and are used only to identify the models you can run.

You are responsible for complying with Replicate's Terms of Service and the license of each model you invoke. Bundled third-party open-source components and their licenses are listed in THIRD_PARTY_LICENSES.md. The banner/logo use the Inter typeface (SIL Open Font License 1.1).


License

MIT — see LICENSE.

Available Tools

36 tools
replicate_batch_startStart Async Batch PredictionsA

Run multiple Replicate predictions in parallel as a background job. Returns a job_id immediately — the predictions run in the background. Poll replicate_batch_status for progress and results.

Use this when you have 2–50 predictions to run and don't want to block. Each item specifies its own model and input, so you can mix models in one batch.

IMPORTANT: model must be a full Replicate identifier ("owner/name" or "owner/name:version"), not a curated shortcut like "flux-schnell". Use replicate_get_model_schema to look up the correct identifier.

Args:

  • items (array, 1–50): Predictions to run. Each: { model: "owner/name[:version]", input: {...} }.

  • concurrency (1–10, default 3): Max simultaneous predictions. Raise with caution — Replicate rate-limits free accounts.

  • download (boolean, default true): Download output files locally.

  • timeout_ms_per_item (default 300000): Per-prediction timeout. Timed-out items have pending=true in their result.

  • ttl_hours (1–72, default 1): How long to keep results in memory. Job state is lost if the MCP server restarts.

Returns: { job_id, total, message }

Example: items=[ { model: "black-forest-labs/flux-schnell", input: { prompt: "a red fox" } }, { model: "black-forest-labs/flux-schnell", input: { prompt: "a blue whale" } }, ] → Returns { job_id: "abc-123", total: 2, message: "..." } → Then poll: replicate_batch_status({ job_id: "abc-123" })

Inputs: items (required), download, ttl_hours, concurrency, +1 more.

replicate_batch_statusGet Batch Job StatusA
Read-onlyIdempotent

Poll the status of an async batch job started with replicate_batch_start.

Args:

  • job_id (string): Job ID returned by replicate_batch_start.

  • include_results (boolean, default true): Include full PredictionResult per item. Set false for a counts-only summary while the job is still running.

Returns structuredContent: { job_id, overall_status, total, succeeded, failed, running, pending, created_at, expires_at, items: [{ index, model, status, prediction_id, result?, error?, started_at, completed_at }] }

overall_status: "running" — predictions still in progress "completed" — all items succeeded "partial" — all done, at least one failed

Tip: Poll every 10–30 seconds until overall_status is "completed" or "partial".

Inputs: job_id (required), include_results.

replicate_cancel_predictionCancel a Replicate predictionA
DestructiveIdempotent

Cancel an in-progress prediction by its ID. Useful for long-running async jobs (video, large LLM) when the user no longer needs the result.

Args:

  • prediction_id (string): ID of the prediction to cancel (returned by an earlier generate_* call).

Returns: PredictionSummary with updated status (typically "canceled").

Inputs: prediction_id (required).

replicate_cancel_trainingCancel a Replicate trainingA
DestructiveIdempotent

Cancel an in-progress training run by its ID. Trainings can run for many minutes and cost real money — cancel when no longer needed.

Args:

  • training_id: ID of the training to cancel.

Returns structuredContent: TrainingSummary with the updated status (typically "canceled").

Inputs: training_id (required).

replicate_chatChat with an LLM via ReplicateA

Run a large language model hosted on Replicate. Use this for free-form text generation, Q&A, code writing, summarisation, translation — anything where the input is text and the output is text.

Args:

  • prompt (string): User message.

  • model (string, default "llama-3-70b"): Curated key (llama-3.1-405b, llama-3-70b, llama-3-8b, mistral-7b, mixtral-8x7b, deepseek-r1) or "owner/name".

  • system_prompt (string, optional): Persona / instructions.

  • max_tokens (1-8192, optional): Generation limit.

  • temperature (0-2, optional): Sampling temperature.

  • extra_input (object, optional): Model-specific extras (top_p, top_k, frequency_penalty, etc.).

  • download (boolean, default false): No file outputs; leave false.

  • timeout_ms (5000-1800000, optional): Default 300000.

Returns: PredictionResult with text_output[0] containing the model's reply (later entries are raw streamed segments if applicable).

Examples:

  • prompt="Explain quantum entanglement in two sentences.", model="llama-3-70b"

  • prompt="Write a Python function to compute Levenshtein distance.", model="mistral-large", system_prompt="You are an expert software engineer."

Inputs: prompt (required), model, download, max_tokens, +4 more.

replicate_clone_voiceClone a voice with ReplicateA

Synthesize speech in a cloned voice. Provide a short reference audio sample (~5-30 s) and the text to speak; the model reproduces the voice characteristics.

DISPLAY REQUIREMENT — after this tool returns successfully, include the URL printed in the tool's text content as a markdown link [Audio](URL) so the user can play it. URLs expire in ~24h.

Args:

  • text (string, 1-5000): Text to synthesize in the cloned voice.

  • reference_audio_url (URL): URL of the voice sample to clone from. Use replicate_upload_file to upload a local file first.

  • language (string, optional): ISO-639 code (e.g. "en", "es", "it"). Default "en".

  • model (string, default "xtts-v2"): Curated key (xtts-v2, openvoice-v2) or "owner/name[:version]".

  • extra_input (object, optional): Model-specific extras.

  • download (boolean, default true).

  • timeout_ms: Default 300000.

Returns: PredictionResult. local_paths contain WAV/MP3 files.

Examples:

  • text="Hello world, this is my cloned voice.", reference_audio_url="<url-to-your-voice-sample.wav>"

  • text="Buongiorno a tutti!", reference_audio_url="", language="it"

Inputs: text (required), reference_audio_url (required), model, download, +3 more.

replicate_create_trainingStart a Replicate fine-tune / training runA

Kick off a fine-tuning (training) run on a trainable base model — e.g. a Flux LoRA trainer — with your dataset and hyperparameters. Returns immediately with a training ID; poll it with replicate_get_training.

Args:

  • model: BASE trainer "owner/name" (or "owner/name:version" to pin the trainer version inline). e.g. "ostris/flux-dev-lora-trainer".

  • version (optional): trainer version id. Required unless pinned inline on model.

  • destination: "owner/name" the trained weights are pushed to. The destination model must already exist on your account.

  • input: training inputs as a JSON object (dataset URL + hyperparameters). Call replicate_get_model_schema on the trainer to see its exact inputs.

Returns structuredContent: TrainingSummary { id, status, model, version, destination, created_at, completed_at, output_version, error }.

Inputs: model (required), destination (required), input, version.

replicate_embed_textCompute text embeddingsA
Idempotent

Convert text(s) into numeric embedding vectors. Useful for RAG, semantic search, clustering, similarity scoring.

Args:

  • texts: A single string or an array of strings (max 256). Each text is embedded independently.

  • model (default "bge-large"): Curated (bge-large, jina-embeddings-v3, all-minilm) or "owner/name".

  • extra_input (object, optional): Model-specific extras (e.g. {task: "retrieval.query"} for jina v3).

Returns: PredictionResult — the embedding vectors are in structuredContent.output (model-specific shape).

Inputs: texts (required), model, download, timeout_ms, +1 more.

replicate_estimate_costEstimate the USD cost of a Replicate predictionA
Read-onlyIdempotent

Return an approximate dollar-cost estimate for a planned prediction BEFORE running it. Prices are a hand-curated snapshot — actual billing comes from Replicate. Call this when the user asks "how much would X cost" or before launching a costly model.

Args:

  • model: Replicate "owner/name" id or a curated short key (e.g. "flux-schnell", "kling-pro").

  • num_outputs (1-20, optional): How many outputs to estimate. Default 1.

  • duration_seconds (1-600, optional): Required for per-second models (video, music, transcription, LLM).

Returns structuredContent: { resolved_model_id, num_outputs, duration_seconds, estimated_usd, pricing_basis, note }.

Examples:

  • model="flux-schnell", num_outputs=4 → ~$0.012 (4 × $0.003 per_run)

  • model="kling-pro", duration_seconds=5 → ~$0.45 (5 × $0.09 per_second)

  • model="meta/meta-llama-3-70b-instruct", duration_seconds=10 → ~$0.024 (10 × $0.0024 per_second)

Inputs: model (required), num_outputs, duration_seconds.

replicate_generate_3dGenerate a 3D model with ReplicateA

Generate a 3D mesh (GLB/OBJ) from a text prompt or a reference image. 3D generation is slow — typically 1-5 minutes.

DISPLAY REQUIREMENT — after this tool returns successfully, include the download URL(s) so the user can open the 3D file. URLs expire in ~24h.

Args:

  • prompt (string, optional): Text description of the 3D object. Provide at least one of prompt or image_url.

  • image_url (URL, optional): Reference image to convert to 3D. Provide at least one of prompt or image_url. Use replicate_upload_file for local files.

  • model (string, default "hunyuan-3d"): Curated key (hunyuan-3d, rodin, triposr) or "owner/name[:version]".

  • extra_input (object, optional): Model-specific extras (e.g. {num_inference_steps: 50}).

  • download (boolean, default true): Download the GLB/OBJ locally.

  • timeout_ms: Default 300000. For complex objects, increase or use the pending+poll flow.

Returns: PredictionResult. local_paths will contain .glb or .obj files.

Examples:

  • prompt="A red ceramic teapot" → hunyuan-3d

  • image_url="", model="triposr" → fast single-image 3D

  • image_url="", model="rodin" → high-quality 3D

Inputs: model, prompt, download, image_url, +2 more.

replicate_generate_audioGenerate Music or Audio with ReplicateA

Generate music, ambient audio, or full songs from a text prompt.

DISPLAY REQUIREMENT — after this tool returns successfully, include the URL(s) printed in the tool's text content as a markdown link [Audio](URL) in your reply so the user can play it. URLs expire in ~24h.

Models:

  • "musicgen" (default): Meta MusicGen. Instrumental music up to 30s. prompt → "prompt" field.

  • "ace-step": Full songs with lyrics. prompt → "tags" field (style/genre tags). Pass lyrics separately via extra_input.lyrics. ~3-4 minutes runtime.

  • "riffusion": Loop-friendly ambient/electronic. prompt → "prompt_a" field. No duration control.

  • "minimax-music": MiniMax Music 2.6. Full songs up to 6min. prompt=style description; pass lyrics via extra_input.lyrics.

  • "lyria-3-pro": Google Lyria 3 Pro. Full songs up to 3min WITH sung vocals. Put genre, mood, lyrics, and structure ([Verse]/[Chorus]) directly in the prompt. No duration — do NOT pass duration_seconds. Also "lyria-3" (30s clips) and "lyria-2" (48kHz instrumental).

Args:

  • prompt (string): Description of the music. For ace-step this maps to the "tags" field (style tags like "rock, guitar, upbeat"). For riffusion this maps to "prompt_a". For lyria put genre/mood/lyrics/structure here.

  • model (string, default "musicgen"): Curated key (musicgen, ace-step, riffusion, minimax-music, lyria-3-pro, lyria-3, lyria-2) or "owner/name[:version]".

  • duration_seconds (1-300, optional): Duration in seconds. Supported by musicgen and ace-step. Ignored for riffusion and the lyria models (they have no duration parameter).

  • extra_input (object, optional): Additional inputs. Examples: {temperature: 1.0, top_k: 250} for MusicGen; {lyrics: "verse lyrics here"} for ace-step.

  • download (boolean, default true): Download as MP3/WAV.

  • timeout_ms: Default 300000 (5min).

Returns: PredictionResult. local_paths contain audio files.

Examples:

  • prompt="upbeat synthwave with driving bassline", duration_seconds=15 → musicgen

  • prompt="indie folk, acoustic guitar, female vocals", model="ace-step", extra_input={lyrics: "Leaving home on a rainy day..."}

  • prompt="ambient lo-fi chill", model="riffusion"

Inputs: prompt (required), model, download, timeout_ms, +2 more.

replicate_generate_imageGenerate Image with ReplicateA

Generate one or more images from a text prompt using a Replicate image model.

Use this for any "draw / create / generate an image of …" request. By default it uses Flux Schnell (fast, ~2 seconds per image).

DISPLAY REQUIREMENT — after this tool returns successfully, you MUST embed the image inline in your reply by pasting ONE of the three embed blocks the tool prints verbatim (Option 1 iframe, Option 2 , or Option 3 markdown — try them in that order; pick the first one your chat client renders). The iframe variant scales to the chat column width with the image's native aspect ratio; the variant is a responsive fallback; markdown is the universal last resort. Place the chosen embed BEFORE any descriptive prose. Do NOT paraphrase the URL or omit the embed — the user wants the image to appear in the main chat flow, not only inside the collapsed tool widget. URLs expire in ~24h.

Args:

  • prompt (string): Text description of the image to generate.

  • model (string, default "flux-schnell"): Either a curated key (flux-schnell, flux-dev, flux-pro, flux-2-max, sd-3.5-large, recraft-v3, recraft-v4.1, ideogram-v2, imagen-3, seedream) or a full Replicate identifier "owner/name[:version]".

  • aspect_ratio ("1:1" | "16:9" | "9:16" | "4:3" | "3:4" | "21:9" | "3:2" | "2:3", optional): Aspect ratio. Default 1:1.

  • num_outputs (1-4, optional): How many images to generate.

  • seed (integer, optional): Random seed for reproducible output.

  • extra_input (object, optional): Model-specific extra inputs (e.g. {guidance: 3.5, num_inference_steps: 28}). Use replicate_get_model_schema if unsure.

  • download (boolean, default true): Download files locally to ~/Downloads/replicate-mcp/.

  • timeout_ms (5000-1800000, optional): Max wait. Default 300000 (5min).

Returns structuredContent matching PredictionResult: { "status": "starting" | "processing" | "succeeded" | "failed" | "canceled", "prediction_id": string, "model": string, "urls": string[], // Replicate URLs (expire ~24h) "local_paths": string[], // Absolute paths on disk when download=true "metrics": { "predict_time_seconds": number } | undefined, "error": string | undefined, "pending": boolean | undefined // true if timed out — poll via replicate_get_prediction }

Examples:

  • "An origami fox in a misty forest" → uses flux-schnell, 1:1

  • prompt="logo for a coffee shop called Crema", model="recraft-v3" → for text-in-image

  • prompt="cinematic shot of a lighthouse", model="flux-pro", aspect_ratio="21:9", seed=42

Error handling:

  • If REPLICATE_API_TOKEN is missing, returns an actionable error telling the user how to set it.

  • Invalid model IDs return Replicate's error message verbatim.

Inputs: prompt (required), seed, model, download, +4 more.

replicate_generate_speechGenerate Speech (TTS) with ReplicateA

Convert text to natural-sounding speech.

DISPLAY REQUIREMENT — after this tool returns successfully, include the URL printed in the tool's text content as a markdown link [Speech](URL) in your reply so the user can play it. URLs expire in ~24h.

Args:

  • text (string, 1-5000): Text to synthesize.

  • model (string, default "kokoro"): Curated key (kokoro, minimax-speech, chatterbox, gemini-tts, grok-tts) or "owner/name[:version]".

  • voice (string, optional): Voice ID. For Kokoro: af_bella, af_sarah, am_adam, am_michael, bf_emma, bf_isabella, etc. (a-f = American female, b-f = British female, a-m = American male, b-m = British male).

  • speed (0.5-2.0, optional): Speech rate.

  • extra_input (object, optional): Model-specific extras (e.g. {audio_prompt: ""} for voice cloning with Chatterbox).

  • download (boolean, default true).

  • timeout_ms: Default 300000.

Returns: PredictionResult. local_paths contain WAV/MP3 files.

Inputs: text (required), model, speed, voice, +3 more.

replicate_generate_videoGenerate Video with ReplicateA

Generate a video clip from a text prompt (and optionally a starting image). Video generation is slow — typically 1-5 minutes per clip.

DISPLAY REQUIREMENT — after this tool returns successfully, include the URL(s) printed in the tool's text content so the user can open the video. URLs expire in ~24h.

Args:

  • prompt (string): Text description of the video.

  • model (string, default "kling-pro"): Curated key (kling-pro, minimax-video, hunyuan-video, luma-ray, wan-2.2, grok-video, seedance) or "owner/name[:version]".

  • image_url (string, optional): Starting frame for image-to-video. Not all models support this.

  • duration_seconds (1-60, optional): Desired duration. Model-dependent.

  • aspect_ratio ("16:9" | "9:16" | "1:1", optional): Aspect ratio.

  • extra_input (object, optional): Additional model-specific inputs.

  • download (boolean, default true): Download the MP4 locally.

  • timeout_ms: Max wait. Default 300000 (5min). For very long videos, increase or rely on the pending+poll flow.

Returns: PredictionResult (see replicate_generate_image for shape). The local_paths will contain .mp4 files when downloaded.

Tip: If timeout_ms is exceeded, the result will have pending=true and a prediction_id. Wait a minute, then call replicate_get_prediction.

Inputs: prompt (required), model, download, image_url, +4 more.

replicate_get_deploymentInspect a Replicate deploymentA
Read-onlyIdempotent

Get the configuration of one deployment: its current model + version, hardware, and autoscaling min/max instances.

Args:

  • deployment: "owner/name" of the deployment.

Returns structuredContent: DeploymentSummary.

Inputs: deployment (required).

replicate_get_model_schemaGet Replicate Model Input SchemaA
Read-onlyIdempotent

Retrieve metadata and the OpenAPI input/output schema for a specific Replicate model. Use this before replicate_run_model to know which fields the model accepts and what they mean.

Args:

  • model (string): "owner/name" or "owner/name:version".

Returns structuredContent: { "model": string, "description": string | undefined, "visibility": string | undefined, "latest_version_id": string | undefined, "input_schema": object | undefined, // OpenAPI schema for inputs "output_schema": object | undefined, // OpenAPI schema for outputs "example_url": string | undefined // Replicate page with examples }

Inputs: model (required).

replicate_get_predictionGet Replicate Prediction StatusA
Read-onlyIdempotent

Retrieve the current status and (if available) outputs of a Replicate prediction by its ID. Use this when a previous generate_* or run_model call returned pending=true (timed out before completion).

Args:

  • prediction_id (string): The ID returned by a previous call.

  • download (boolean, default true): If the prediction has succeeded, download its outputs locally.

Returns: PredictionResult — same shape as replicate_generate_image. If still running, status will be "processing" or "starting" and pending will be true.

Typical flow:

  1. Call replicate_generate_video → returns pending=true with prediction_id=abc123.

  2. Wait ~1 minute.

  3. Call replicate_get_prediction with prediction_id=abc123 → returns succeeded + URLs + local_paths.

Inputs: prediction_id (required), download.

replicate_get_trainingGet a Replicate training by IDA
Read-onlyIdempotent

Retrieve the current state of a training run: status, the resulting trained model version (once it succeeds), and any error.

Args:

  • training_id: ID returned by replicate_create_training.

Returns structuredContent: TrainingSummary.

Inputs: training_id (required).

replicate_inpaintInpaint / outpaint an image with a maskA

Fill masked regions of an image based on a text prompt. Works for both inpainting (replace inside) and outpainting (extend canvas) when the mask covers the target area.

DISPLAY REQUIREMENT — embed the result inline using one of the three blocks (iframe / / markdown) printed by the tool.

Args:

  • image (URL): Source image.

  • mask (URL): Mask image. White = keep, black/transparent = repaint.

  • prompt: Describes what should appear in the masked region.

  • model (default "flux-fill-pro"): Curated (flux-fill-pro, sd-inpaint, ideogram-v2-edit) or "owner/name".

  • extra_input (object, optional): Model-specific extras (e.g. {guidance: 30} for flux-fill-pro).

Inputs: mask (required), image (required), prompt (required), model, +3 more.

replicate_lipsyncLipsync / talking avatar with ReplicateA

Animate a portrait image to speak — either from a text script (model does TTS + lipsync) or from a driving audio file. Produces an MP4 video.

DISPLAY REQUIREMENT — after this tool returns successfully, include the URL(s) so the user can open the video. URLs expire in ~24h.

Args:

  • image_url (URL): Portrait or face image to animate. Use replicate_upload_file for local files.

  • text (string, optional): Script for the avatar to speak. Used by video-avatar (maps to voice_script). At least one of text or audio_url is required.

  • audio_url (URL, optional): Driving audio for lipsync. Required for sadtalker; optional override for video-avatar. At least one of text or audio_url is required.

  • model (string, default "video-avatar"): Curated key (video-avatar, sadtalker) or "owner/name[:version]".

  • extra_input (object, optional): Model-specific extras (e.g. {voice_prompt: "speak slowly"} for video-avatar).

  • download (boolean, default true): Download the MP4 locally.

  • timeout_ms: Default 300000.

Returns: PredictionResult. local_paths contain .mp4 files.

Examples:

  • image_url="<portrait.jpg>", text="Hello! Welcome to our product demo." → video-avatar (TTS + lipsync)

  • image_url="<face.jpg>", audio_url="<speech.wav>", model="sadtalker" → audio-driven lipsync

Inputs: image_url (required), text, model, download, +3 more.

replicate_list_deploymentsList your Replicate deploymentsA
Read-onlyIdempotent

List the deployments on the authenticated Replicate account. A deployment is a private, autoscaled endpoint pinned to a specific model + hardware.

Args:

  • limit (1-100, default 20): How many deployments to return.

Returns structuredContent: { count: number, deployments: DeploymentSummary[] }. Each DeploymentSummary has owner, name, and current_release { model, version, hardware, min_instances, max_instances }.

Inputs: limit.

replicate_list_predictionsList recent Replicate predictionsA
Read-onlyIdempotent

Return the most recent predictions on the authenticated Replicate account. Useful to recover a prediction ID, audit recent calls, or check what's still running.

Args:

  • limit (1-100, default 10): How many predictions to return.

Returns structuredContent: { count: number, predictions: PredictionSummary[] } Each PredictionSummary has id, model, status, created_at, completed_at, url.

Inputs: limit.

replicate_list_trainingsList recent Replicate trainingsA
Read-onlyIdempotent

Return the most recent training runs on the authenticated account.

Args:

  • limit (1-100, default 10): How many trainings to return.

Returns structuredContent: { count: number, trainings: TrainingSummary[] }.

Inputs: limit.

replicate_pipeline_startStart Async Pipeline (DAG of predictions)A

Run a directed acyclic graph (DAG) of Replicate predictions as a background job. Returns a pipeline_id immediately. Poll replicate_pipeline_status for per-step progress and results.

Independent steps run concurrently. Downstream steps auto-start when their dependencies complete. Use "$stepId.field[n]" template strings to pass one step's output as another step's input.

IMPORTANT: model must be a full Replicate identifier ("owner/name" or "owner/name:version"). Curated shortcuts (e.g. "flux-schnell") are not supported — look up the full id via replicate_get_model_schema.

Template reference syntax: "$gen.urls[0]" → first URL output of step "gen" "$gen.urls" → full URLs array "$gen.local_paths[0]" → first downloaded local path "$gen.text_output[0]" → first text output (for LLMs)

Args:

  • steps (array, 1–20): Pipeline steps. Each: { id, model, input, depends_on? }. depends_on is inferred from $ref patterns in input when omitted.

  • concurrency (1–5, default 3): Max simultaneous steps.

  • download (boolean, default true): Download step outputs locally.

  • timeout_ms_per_step (default 300000): Per-step timeout.

  • ttl_hours (1–72, default 1): How long to keep results in memory. Lost on server restart.

Returns: { pipeline_id, total, message }

Example — generate + upscale + remove background in parallel: steps=[ { "id": "gen", "model": "black-forest-labs/flux-schnell", "input": { "prompt": "a fox" } }, { "id": "upscale", "model": "nightmareai/real-esrgan", "input": { "image": "$gen.urls[0]", "scale": 4 } }, { "id": "no_bg", "model": "lucataco/remove-bg", "input": { "image": "$gen.urls[0]" } } ] upscale and no_bg both depend on gen, run in parallel after gen completes.

Inputs: steps (required), download, ttl_hours, concurrency, +1 more.

replicate_pipeline_statusGet Pipeline StatusA
Read-onlyIdempotent

Poll the status of a pipeline started with replicate_pipeline_start.

Args:

  • pipeline_id (string): Pipeline ID returned by replicate_pipeline_start.

  • include_outputs (boolean, default true): Include full PredictionResult per step. Set false for a counts-only summary while the pipeline is running.

Returns structuredContent: { pipeline_id, overall_status, total, succeeded, failed, skipped, running, pending, created_at, expires_at, steps: [{ id, model, status, prediction_id, result?, error?, skip_reason?, started_at, completed_at }] }

overall_status: "running" — steps still executing "completed" — all steps succeeded "partial" — all done, at least one failed or was skipped (failed dependency or budget error)

Note: pipeline-level errors (cycle detected, unknown depends_on) are rejected at replicate_pipeline_start with an error response — they never produce a pollable pipeline.

Tip: Poll every 10–30 seconds until overall_status is "completed" or "partial".

Inputs: pipeline_id (required), include_outputs.

replicate_recommend_modelRecommend the Best Model for a TaskA
Read-onlyIdempotent

Rank the curated models in a category by a priority (speed, cost, quality, or balanced) and return recommendations with cost estimates and reasoning. This does NOT run anything — it advises which model to use.

Workflow: call this to pick a model, then call the matching generate tool (e.g. replicate_generate_image) with model set to the recommended key.

Args:

  • category (required): One of image, video, audio, tts, llm, vision, upscale, bg, stt, inpaint, segment, embed, voiceclone, threed, lipsync.

  • priority (default "balanced"): "speed" (fastest), "cost" (cheapest), "quality" (best), or "balanced" (weighted).

  • task_description (optional): Free text. Keyword hints like "quick draft" or "professional logo" nudge balanced ranking.

  • max_cost_usd (optional): Exclude models estimated above this cost.

  • duration_seconds (optional, 1–600): For per-second-priced categories (video, audio), used in cost estimation.

Returns structuredContent: { category, priority, recommendations: [{ key, model_id, speed, est_cost_usd, score, reason }], // top 5 count }

Examples:

  • category="image", priority="speed" → flux-schnell first

  • category="image", priority="quality" → highest-fidelity model first

  • category="video", priority="cost", duration_seconds=5 → cheapest per-5s clip

Inputs: category (required), priority, max_cost_usd, duration_seconds, +1 more.

replicate_refresh_modelsDiscover New Popular Replicate ModelsA
Read-only

Search Replicate for popular models NOT yet in the curated registry. Returns suggestions only — does not modify code.

Use this to find new models worth adding. Then ask Claude to edit src/models.ts with the ones you want.

Args:

  • categories (string[], optional): Which categories to check. Default: all 15 (image, video, audio, tts, llm, vision, upscale, bg, stt, inpaint, segment, embed, voiceclone, threed, lipsync).

  • min_run_count (integer, optional): Minimum run_count threshold. Default: 1000.

  • limit_per_category (integer, optional): Max suggestions per category (1-20). Default: 5.

Returns structuredContent: { "checked_at": string, "categories_checked": string[], "suggestions": [{ category, owner, name, model_id, run_count, description, replicate_url }], "already_curated": number, "total_suggestions": number }

Examples:

  • "Check for new popular models" → all categories, min 1000 runs

  • categories=["image","video"], min_run_count=10000 → only top-tier image/video models

Inputs: categories, min_run_count, limit_per_category.

replicate_remove_backgroundRemove the background from an imageA

Produce a transparent-background version (PNG) of an image.

DISPLAY REQUIREMENT — after this tool returns successfully, embed the cut-out image inline using one of the three blocks (iframe / / markdown) printed by the tool.

Args:

  • image (string URL): URL of the source image.

  • model (string, default "rembg"): Curated key (rembg, birefnet, briaai-rmbg) or "owner/name".

  • extra_input (object, optional): Model-specific extras.

  • download (boolean, default true): Download the cut-out PNG locally.

Returns: PredictionResult with urls + local_paths to a transparent PNG.

Examples:

  • image="" → rembg quick cut

  • image="", model="birefnet" → sharper edge for hair

Inputs: image (required), model, download, timeout_ms, +1 more.

replicate_run_deploymentRun a prediction on a Replicate deploymentA

Run a prediction against a deployment's current release. WAITS for the prediction to finish and (by default) auto-downloads the outputs locally — same UX as the curated generate_* tools.

Args:

  • deployment: "owner/name" of the deployment to run.

  • input: model input parameters as a JSON object (same shape the deployment's underlying model expects).

  • download (default true): download output files locally.

  • timeout_ms (optional): max ms to wait before returning a pending result you can poll with replicate_get_prediction.

Returns the standard prediction result (inline image preview / text output, URLs, local_paths, prediction_id).

Inputs: deployment (required), input, download, timeout_ms.

replicate_run_modelRun Any Replicate ModelA

Generic escape hatch: run ANY model in the Replicate catalog by its "owner/name" identifier. This tool gives Claude access to the entire Replicate model catalog — anything not covered by the curated specialised tools (image, video, audio, speech, chat, vision, upscale, remove-bg) can be reached from here.

DISPLAY REQUIREMENT — if the result includes image URLs, paste ONE of the embed blocks the tool prints (iframe / / markdown — try in order) verbatim in your reply so the image renders inline in the chat.

Use this for any category WITHOUT a curated specialised tool, including but not limited to:

  • Embeddings (sentence-transformers, BGE, Jina)

  • Segmentation (SAM, Segment Anything)

  • Depth estimation (MiDaS, ZoeDepth, Marigold)

  • Inpainting / outpainting (LaMa, Stable Diffusion Inpaint, controlnet-inpaint)

  • ControlNet variants (canny, depth, openpose, normal-map)

  • Face / pose / hand detection (insightface, mediapipe, etc.)

  • 3D generation (TripoSR, Wonder3D, InstantMesh)

  • Audio-to-text / speech recognition (whisper, Distil-Whisper)

  • Audio separation / stem splitting (Demucs, MDX)

  • Style transfer, colourisation, deblurring, denoising

  • Code completion / instruction-tuned code models (CodeLlama, DeepSeek-Coder)

  • Music continuation / source separation

  • ANY newly released model not yet in the curated registries

Workflow:

  1. (Optional) Call replicate_search_models to discover models by keyword (e.g. "image segmentation", "speech to text").

  2. (Recommended) Call replicate_get_model_schema with "owner/name" to inspect required inputs.

  3. Call this tool with the model id and an input object matching that schema.

Args:

  • model (string): "owner/name" (latest official version) or "owner/name:version_hash" (pinned).

  • input (object): Model-specific input parameters.

  • download (boolean, default true): Download outputs locally.

  • timeout_ms: Default 300000.

Returns: PredictionResult.

Examples:

  • Upscale an image: model="nightmareai/real-esrgan", input={"image": "https://example.com/in.png", "scale": 4}

  • Remove background: model="lucataco/remove-bg", input={"image": ""}

  • Run an LLM (output is text, not a file, so local_paths will be empty): model="meta/meta-llama-3-70b-instruct", input={"prompt": "Explain quantum entanglement in two sentences."}

Inputs: input (required), model (required), download, timeout_ms.

replicate_search_modelsSearch Replicate Model CatalogA
Read-onlyIdempotent

Search the Replicate catalog by free-text query. Returns up to 25 matching models with names, descriptions, and URLs.

Args:

  • query (string, 1-200 chars): Free-text search. Examples: "image upscaler", "voice cloning", "depth estimation", "code generation".

Returns structuredContent: { "count": number, "models": [ { "owner": string, "name": string, "description": string | undefined, "url": string, "run_count": number | undefined, "cover_image_url": string | undefined } ] }

Tip: Once you find a promising model, call replicate_get_model_schema with "owner/name" to see its inputs before calling replicate_run_model.

Inputs: query (required).

replicate_segmentSegment an image (SAM 2 / Grounded-SAM)A

Produce a segmentation mask of an image. Use SAM 2 for point/box-prompt masks (auto-mask everything when no prompt given) or Grounded-SAM for text-prompt masking like "the red car".

DISPLAY REQUIREMENT — embed the mask result inline using one of the three blocks printed by the tool.

Args:

  • image (URL): Source image.

  • prompt (string, optional): Text prompt for grounded segmentation. Required for grounded-sam.

  • model (default "sam-2"): Curated (sam-2, grounded-sam) or "owner/name".

  • extra_input (object, optional): SAM-specific tuning (e.g. {points_per_side: 32}).

Inputs: image (required), model, prompt, download, +2 more.

replicate_transcribe_audioTranscribe Audio / Video with WhisperA

Transcribe an audio or video file to text using Whisper-family models on Replicate.

Args:

  • audio (URL): URL of the audio (or video) to transcribe.

  • model (default "incredibly-fast-whisper"): Curated key (whisper, incredibly-fast-whisper, whisperx, scribe) or "owner/name".

  • language (string, optional): ISO-639 hint (e.g. "en", "it"). Default: auto-detect.

  • translate_to_english (bool, optional): Translate the transcript to English instead of preserving source language.

  • extra_input (object, optional): Model-specific extras (e.g. {batch_size: 24} for incredibly-fast-whisper).

Returns: PredictionResult with text_output containing the transcript.

Inputs: audio (required), model, download, language, +3 more.

replicate_upload_fileUpload a file (path or base64) to ReplicateA

Upload a file to Replicate's file storage and get back a URL valid for ~24 hours. Pass the returned URL as a model input (e.g. image for upscale/inpaint/vision, image_url for video, reference_audio_url for voice clone).

Two input modes — provide EXACTLY ONE:

  • file_path: absolute local path of a file on the machine running the server.

  • base64_data: the file's bytes as base64 (a bare base64 string OR a full "data:;base64,..." URI). Use this when you hold bytes in memory but have no local path — e.g. an image a user dropped into the chat that a code container can read and base64-encode. NOTE: an MCP client (Claude Desktop) generally cannot reproduce a large dragged-in image's exact bytes as a tool argument — base64 mode is for callers that genuinely have the bytes (web container, programmatic clients).

Args:

  • file_path (string, optional): Absolute local path. Provide this OR base64_data.

  • base64_data (string, optional): base64 contents or data: URI. Provide this OR file_path.

  • mime_type (string, optional): MIME override (e.g. 'image/png'). Auto-detected from the path extension or a data: URI; defaults to application/octet-stream for raw base64.

  • file_name (string, optional): Name for a base64 upload.

Returns structuredContent: { url, file_id, name }

  • url: Replicate-hosted URL (~24h expiry) — pass this as a model input.

Examples:

  • file_path="C:/Users/me/photo.png"

  • base64_data="data:image/png;base64,iVBORw0KG...", → uploads, returns URL

Inputs: file_name, file_path, mime_type, base64_data.

replicate_upscale_imageUpscale / restore an image with ReplicateA

Upscale an image to higher resolution. Optional face restoration for photos.

DISPLAY REQUIREMENT — after this tool returns successfully, embed the upscaled image inline using one of the three blocks (iframe / / markdown) printed by the tool. Place it BEFORE descriptive prose. URLs expire ~24h.

Args:

  • image (string URL): URL of the source image.

  • model (string, default "real-esrgan"): Curated key (real-esrgan, clarity-upscaler, swinir, gfpgan) or "owner/name".

  • scale (1-10, optional): Upscale factor. Default 4 for real-esrgan; 2 for gfpgan; 2 for clarity-upscaler.

  • extra_input (object, optional): Model-specific extras (e.g. {face_enhance: true} for real-esrgan).

  • download (boolean, default true): Download upscaled file locally.

Returns: PredictionResult with urls + local_paths to the upscaled image.

Examples:

  • image="", scale=4 → real-esrgan

  • image="", model="gfpgan", scale=2 → restoration

  • image="", model="clarity-upscaler", scale=2

Inputs: image (required), model, scale, download, +2 more.

replicate_visionAnalyse / caption an image with a vision modelA

Run a vision-language model to describe, caption, or answer questions about an image.

Args:

  • image (string URL): URL of the image to analyse.

  • prompt (string, optional): Question or instruction (e.g. "describe this image", "count the people"). Default is a generic caption.

  • model (string, default "llava-13b"): Curated key (llava-13b, llava-v1.6-34b, blip-2, qwen-vl) or "owner/name".

  • max_tokens (1-4096, optional): Response length.

  • extra_input (object, optional): Model-specific extras.

Returns: PredictionResult with text_output containing the model's textual answer.

Examples:

  • image="https://example.com/photo.jpg", prompt="What objects are visible?"

  • image="", prompt="Read the values off this chart and list them.", model="llava-v1.6-34b"

Inputs: image (required), model, prompt, download, +3 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.8/5.0

    Scored across 36 tools

    Disambiguation3/5

    Most tools target distinct actions (generate image/video/audio, upscale, inpaint, train, deploy), but replicate_run_model is a generic escape hatch that overlaps every specialized generation tool, and its examples duplicate curated tools like upscale and remove-background. The two async multi-run tools, replicate_pipeline_start and replicate_batch_start, are related enough to require careful reading despite their descriptions.

    Naming Consistency4/5

    Almost all tools use a snake_case replicate_ prefix with readable verb/noun ordering. Minor deviations exist: some tools put the noun first (replicate_pipeline_start, replicate_batch_status), and a few are single verbs/nouns (replicate_chat, replicate_vision, replicate_inpaint, replicate_segment, replicate_lipsync).

    Tool Count2/5

    36 tools is well above the recommended 3-15 range and feels heavy even for a broad Replicate platform. The surface includes many specialized generation tools, asynchronous job management, training/deployment management, and discovery utilities, making it harder to scan and increasing overlap risk.

    Completeness4/5

    Coverage is strong across media generation, generic model execution, schema inspection, predictions, batches, pipelines, trainings, deployments, file upload, and model discovery. Minor gaps remain around deployment lifecycle management (list/get/run exist, but create/update/delete are absent) and file management beyond upload.

    Maintenance

    ActivityMaintained
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers