Index of every page on this site: llms.txt
All skills
Run it yourself

Create images, video, and audio with the fal.ai MCP server. Use for text-to-image, image edits, text-to-video, image-to-video, speech, music, sound effects, and video-to-audio tasks.

  • 1 file
  • 8.2 KB
  • Updated 2 months ago
  • GitHub
Use this Skill: https://skilld.dev/gh/agenticluke/fal-media-maker-plus/skill

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈47 tokens for metadata: the name and description. ≈2k when used: this file.

Description uses 2.5% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈197 characters, or 2.5%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

fal.ai Media Creation

Original skill by ECC. Credit: ECC.

This skill can change fast. Model names, prices, inputs, output types, and tool names may change. Check the current model data before you promise a model, price, setting, or file type.

Use the fal.ai MCP server to make images, video, and audio.

When to use this skill

Use this skill when the user wants to:

  • Make an image from text
  • Edit an image
  • Make a video from text or an image
  • Make speech, music, or sound effects
  • Add sound to a video
  • Make a thumbnail or other media file

Do not use this skill when the user only wants to edit media with local tools.

Setup

The fal.ai MCP server must be set up first. Add this entry to ~/.claude.json:

{
  "fal-ai": {
    "command": "npx",
    "args": ["-y", "fal-ai-mcp-server"],
    "env": {
      "FAL_KEY": "YOUR_FAL_KEY_HERE"
    }
  }
}

Get an API key from fal.ai.

Never print, save, or share the key in chat. If the server or key is missing, explain what is missing and stop.

Tools

The server may offer these tools:

  • search: Find models by task or key words.
  • find: Get the current inputs and rules for a model.
  • generate: Start a media job.
  • result: Get the result of a job.
  • status: Check if a job is done.
  • cancel: Stop a job that is still running.
  • estimate_cost: Get a cost guess.
  • models: List common models.
  • upload: Upload a local file for use as input.

Tool names may change. Use the names shown by the active server.

Safe work flow

Follow these steps:

  1. Ask for any key detail that is missing, such as size, length, style, or source file.
  2. Use search if the right model is not clear.
  3. Use find before the first run. Check the exact model ID and allowed inputs.
  4. Upload local source files with upload.
  5. Check cost before a costly job or when the user asks about cost.
  6. Run generate with only inputs that the model accepts.
  7. If the job is not done at once, save its job ID.
  8. Use status or result until it is done or fails.
  9. Give the user the output link and key job details.

Do not keep retrying a failed paid job. Read the error first. Fix the input, then ask before a new costly run.

Do not say that a seed will make the same result every time. It may help, but models and systems can change.

Image creation

Search for a current text-to-image model:

search(query: "text to image")
find(endpoint_ids: ["<model_id>"])

Example call after find confirms the inputs:

generate(
  app_id: "<model_id>",
  input_data: {
    "prompt": "A small red boat on a calm lake at sunrise",
    "image_size": "landscape_16_9",
    "num_images": 1,
    "seed": 42
  }
)

Common image inputs may include:

Input Use
prompt Says what the image should show
image_size Sets the shape and size
num_images Sets how many images to make
seed May help make a similar result
guidance_scale May set how closely the model follows the prompt

These inputs are not shared by every model. Check with find.

Image editing

Upload the source image first:

upload(file_path: "/path/to/image.png")

Then use a model that supports image editing:

generate(
  app_id: "<image_edit_model_id>",
  input_data: {
    "prompt": "Keep the same scene. Change the style to soft watercolor.",
    "image_url": "<uploaded_url>"
  }
)

State what must stay the same and what must change. If the model needs a mask, ask the user for one or make sure they approve how the edit area will be chosen.

Video creation

Find and check a current video model:

search(query: "text to video")
find(endpoint_ids: ["<model_id>"])

Then run it with confirmed inputs:

generate(
  app_id: "<model_id>",
  input_data: {
    "prompt": "A slow drone view over a mountain lake at sunrise",
    "duration": "5s",
    "aspect_ratio": "16:9",
    "seed": 42
  }
)

For image-to-video, upload the image and pass its URL:

generate(
  app_id: "<image_to_video_model_id>",
  input_data: {
    "prompt": "The camera moves back slowly. A light wind moves the trees.",
    "image_url": "<uploaded_image_url>",
    "duration": "5s"
  }
)

Common video inputs may include:

Input Use
prompt Says what happens in the video
duration Sets the video length
aspect_ratio Sets the frame shape
seed May help make a similar result
image_url Gives the first image or source image

Check whether the model makes sound. Do not promise sound unless the model data says it does.

A good video prompt states:

  • The main subject
  • The action
  • The camera move
  • The light and mood
  • Any sound the model should make

Audio creation

Find the right model for the audio task:

search(query: "text to speech")
search(query: "text to music")
search(query: "sound effects")
find(endpoint_ids: ["<model_id>"])

Example speech call:

generate(
  app_id: "<speech_model_id>",
  input_data: {
    "text": "Hello. Welcome to the demo.",
    "speaker_id": 0
  }
)

Example video-to-audio call:

generate(
  app_id: "<video_to_audio_model_id>",
  input_data: {
    "video_url": "<uploaded_video_url>",
    "prompt": "Soft forest sounds with birds and light wind"
  }
)

Check language, voice, length, file type, and use rights before the run. Do not copy a real person's voice without clear permission.

Other audio tools, such as ElevenLabs or VideoDB, are outside this skill. Do not call them unless the user asks for them and they are set up.

Cost checks

Use the active server's cost tool before a costly run:

estimate_cost(
  estimate_type: "unit_price",
  endpoints: {
    "<model_id>": {
      "unit_quantity": 1
    }
  }
)

A cost result is only a guess. Tell the user what unit it covers. If cost data is missing, say so. Do not guess a price.

Full usage example

User request:

Make a five-second, wide video of ocean waves at sunset. Keep the cost low.

Work flow:

search(query: "low cost text to video")
find(endpoint_ids: ["<chosen_model_id>"])
estimate_cost(
  estimate_type: "unit_price",
  endpoints: {
    "<chosen_model_id>": {
      "unit_quantity": 1
    }
  }
)
generate(
  app_id: "<chosen_model_id>",
  input_data: {
    "prompt": "Wide view of ocean waves at sunset. Warm orange light. The camera stays still. Natural wave motion.",
    "duration": "5s",
    "aspect_ratio": "16:9"
  }
)
status(request_id: "<job_id>")
result(request_id: "<job_id>")

If find shows different input names, use those names. If the model does not support five seconds or 16:9, tell the user and offer the closest valid choice.

Edge cases

  • If no model fits, say what part is not supported.
  • If a local file is missing, ask for the right path or file.
  • If upload fails, check file size and file type.
  • If a URL cannot be read, ask for a public URL or a local file.
  • If the prompt breaks a model rule, explain the issue and ask for a safe change.
  • If the job takes a long time, report that it is still running. Do not start a copy.
  • If the job fails after a charge, keep the job ID and error text for the user.
  • If the output is empty or broken, check the result data before trying again.
  • If the user asks for many files, confirm the count and cost first.
  • If the user asks to cancel, call cancel with the saved job ID.
  • If the output link will expire, tell the user to save the file soon.
  • If the user needs private media, warn them before upload and get clear approval.

Tips

  • Start with a low-cost draft when the user wants to test ideas.
  • Use one image or a short video first.
  • Keep prompts clear and short.
  • For image edits, list what must not change.
  • For video, focus on action and camera moves.
  • Image-to-video often gives more control than text-to-video.
  • Check cost before long video, high quality, or large batch jobs.

Related skills

  • videodb: Video work, edits, and streams
  • video-editing: Video editing steps
  • content-engine: Social media content creation

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

No third-party reports yet.

Signed by skilld at b52fffb. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub last month.

Steadyupdated 2 months ago
origin
ECC

README badge

README badge for agenticluke/fal-media-maker-plus